Enables workflow automation through Automatisch that can integrate with GitHub, such as creating workflows that respond to GitHub events like new issues.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Automatisch MCP Server show me my active workflows"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol (MCP) server that provides AI assistants with access to Automatisch workflow automation capabilities.
This MCP server enables AI assistants to interact with Automatisch, an open-source Zapier alternative for workflow automation. It provides tools to manage workflows, connections, executions, and app integrations.
Related MCP server: n8n Workflow Builder
Workflow Management: Create, read, update, delete, and test workflows
Connection Management: Manage app connections and credentials
Execution Monitoring: View workflow execution history and status
App Discovery: Browse available apps and their capabilities
Testing: Test workflows with sample data
Workflows overview with status summary
App connections listing
Available apps catalog
Recent executions log
Node.js 18+
Running Automatisch instance
Automatisch API access (API key recommended)
Clone or download the MCP server code
Install dependencies:
npm installBuild the project:
npm run buildSet environment variables:
# Automatisch instance URL (default: http://localhost:3001)
export AUTOMATISCH_BASE_URL="http://your-automatisch-instance:3001"
# API key for authentication (optional but recommended)
export AUTOMATISCH_API_KEY="your-api-key"Add to your Claude Desktop configuration file:
{
"mcpServers": {
"automatisch": {
"command": "npx",
"args": ["-y", "automatisch-mcp-server"],
"env": {
"AUTOMATISCH_BASE_URL": "http://localhost:3001",
"AUTOMATISCH_API_KEY": "your-api-key"
}
}
}
}npm startlist_workflows - List all workflows with optional filtering
get_workflow - Get detailed workflow information
create_workflow - Create new workflow
update_workflow - Update existing workflow
delete_workflow - Delete workflow
test_workflow - Test workflow with sample data
list_connections - List app connections
create_connection - Create new app connection
list_executions - View workflow execution history
get_available_apps - Browse available apps and integrations
# List all active workflows
"Show me all active workflows"
# Create a new workflow
"Create a workflow named 'Email Notifications' that sends emails when new GitHub issues are created"
# Check recent executions
"Show me the recent workflow executions and their status"
# Get workflow details
"Tell me about the workflow with ID 'abc123'"
# List available apps
"What apps are available for integration?"The server interfaces with these Automatisch API endpoints:
GET /api/flows - List workflows
POST /api/flows - Create workflow
PATCH /api/flows/:id - Update workflow
DELETE /api/flows/:id - Delete workflow
GET /api/connections - List connections
POST /api/connections - Create connection
GET /api/executions - List executions
GET /api/apps - List available apps
npm run devnpm run buildnpm run cleanThe server includes comprehensive error handling:
Network connectivity issues with Automatisch
Invalid API responses
Missing required parameters
Authentication failures
Errors are logged and returned as structured responses to the AI assistant.
Use API keys for authentication when available
Ensure Automatisch instance is properly secured
Limit network access to trusted sources
Regularly update dependencies
Connection Failed: Verify AUTOMATISCH_BASE_URL is correct and accessible
Authentication Error: Check AUTOMATISCH_API_KEY is valid
Tool Not Found: Ensure MCP server is properly registered with Claude Desktop
API Errors: Check Automatisch logs for detailed error information
Enable debug logging by setting:
export NODE_ENV=developmentFork the repository
Create a feature branch
Make your changes
Add tests if applicable
Submit a pull request
This project is licensed under the MIT License.
Automatisch - Open source workflow automation
Model Context Protocol - Protocol specification
MCP SDK - TypeScript SDK
For issues related to:
Issues specific to MCP Server integration or this repository: Open an issue here
Automatisch: Visit Automatisch GitHub Issues
MCP Protocol: Check MCP Documentation
Create a new app connection
| Name | Required | Description | Default |
|---|---|---|---|
| appKey | Yes | App identifier (e.g., 'slack', 'github') | |
| name | Yes | Connection name | |
| credentials | Yes | App-specific credentials and configuration |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states the action without behavioral details. It doesn't disclose if this requires specific permissions, whether it's idempotent, what happens on failure, or typical response format, which are critical 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.
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, making it easy to parse quickly, though this conciseness comes at the cost of detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a creation tool with no annotations and no output schema, the description is incomplete. It lacks information on success/failure behavior, return values, error handling, or how it fits with siblings like 'get_available_apps', leaving significant gaps for agent usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are well-documented in the schema. The description adds no extra meaning beyond implying 'app connection' relates to 'appKey', but this is already clear from the schema, meeting the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the action ('create') and resource ('app connection'), which is clear but minimal. It doesn't differentiate from siblings like 'create_workflow' or 'list_connections', leaving ambiguity about what an 'app connection' specifically is versus other connection types or workflows.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention prerequisites like needing 'get_available_apps' first, or contrast with 'list_connections' for viewing existing ones, 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.
Create a new workflow
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Workflow name | |
| description | No | Workflow description | |
| active | No | Whether workflow should be active |
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. 'Create a new workflow' implies a write operation, but it doesn't disclose permissions needed, whether creation is idempotent, error conditions, or what happens upon success (e.g., returns a workflow ID). For a mutation tool with zero annotation coverage, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with zero waste, making it appropriately concise. However, it's under-specified rather than efficiently informative—it could benefit from more detail without losing conciseness. It's front-loaded but lacks depth.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of creating a workflow (a mutation with 3 parameters), no annotations, and no output schema, the description is incomplete. It doesn't explain what a workflow is, what happens after creation, or how to handle errors. For a tool with siblings like 'delete_workflow' and 'update_workflow', more context is needed to ensure proper use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all parameters documented in the schema (name, description, active). The description adds no parameter-specific information beyond what the schema provides, such as constraints on the name or implications of the active flag. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the basic action ('Create a new workflow') which is clear but vague. It doesn't specify what a workflow entails in this context or distinguish it from sibling tools like 'create_connection' or 'update_workflow'. The purpose is understandable but lacks specificity about the resource being created.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, when to choose this over 'update_workflow', or how it relates to sibling tools like 'list_workflows' or 'test_workflow'. Users must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Delete a workflow
| Name | Required | Description | Default |
|---|---|---|---|
| workflowId | Yes | Workflow ID to delete |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states 'Delete' but doesn't disclose behavioral traits such as whether deletion is permanent, reversible, requires specific permissions, affects related data (e.g., executions), or has side effects. This is a significant gap for a destructive operation with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise ('Delete a workflow'), with no wasted words. It's front-loaded and efficiently conveys the core action, though this brevity contributes to gaps in other dimensions. Every sentence (here, one) earns its place by stating the purpose directly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's destructive nature, lack of annotations, and no output schema, the description is incomplete. It doesn't explain what deletion entails, return values, error conditions, or dependencies on sibling tools. For a mutation tool with high complexity risk, more context is needed to guide safe usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'workflowId' documented in the schema. The description doesn't add any parameter details beyond what the schema provides, but with only one parameter and high coverage, the baseline is high. No compensation is needed, but no extra value is added either.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the action ('Delete') and resource ('a workflow'), which is clear but minimal. It doesn't differentiate from siblings like 'update_workflow' or specify what 'delete' entails (e.g., permanent removal vs. archiving). While it avoids tautology, it lacks specificity about scope or consequences.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing the workflow ID from 'get_workflow' or 'list_workflows'), exclusions, or comparisons to siblings like 'update_workflow' for modifications. The agent must infer usage from context alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get list of available apps and their capabilities
| Name | Required | Description | Default |
|---|---|---|---|
| category | No | Filter by app category |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but doesn't add context about traits like whether it's read-only, requires permissions, has rate limits, or what the return format looks like. This leaves significant gaps for a tool that presumably lists resources.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the low complexity (one optional parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose but lacks details on behavioral traits and usage context, making it incomplete for optimal agent decision-making without additional inference.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the input schema fully documents the 'category' parameter. The description doesn't add any meaning beyond this, such as examples of categories or how filtering works, but it doesn't need to compensate for gaps, resulting in a baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'list of available apps and their capabilities', making the purpose understandable. However, it doesn't differentiate from sibling tools like 'list_connections' or 'list_workflows' by specifying what makes 'apps' distinct, which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'list_connections' or 'list_workflows'. It lacks context about prerequisites, such as whether authentication is needed, or exclusions, leaving the agent to infer usage based on the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information about a specific workflow
| Name | Required | Description | Default |
|---|---|---|---|
| workflowId | Yes | Workflow ID to retrieve |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states 'Get detailed information' but doesn't disclose behavioral traits such as whether this is a read-only operation, requires specific permissions, has rate limits, or what the response format includes. For a tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized and front-loaded, though it could be slightly more structured by including usage hints without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (retrieving detailed info), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'detailed information' includes, potential errors, or behavioral aspects, making it inadequate for an agent to fully understand the tool's context and usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'workflowId' documented as 'Workflow ID to retrieve'. The description adds no additional meaning beyond this, such as format examples or constraints. Baseline is 3 since the schema does the heavy lifting, but no extra value is provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('detailed information about a specific workflow'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'list_workflows' or 'test_workflow', which would require specifying what 'detailed information' entails compared to those alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a workflow ID), exclusions, or comparisons to siblings like 'list_workflows' for overviews or 'test_workflow' for validation, leaving usage context unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all app connections
| Name | Required | Description | Default |
|---|---|---|---|
| appKey | No | Filter by specific app |
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 'List all app connections' but doesn't describe the return format (e.g., list of objects, pagination), permissions required, or any rate limits. For a read operation with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste: 'List all app connections'. It's front-loaded and appropriately sized for a simple tool, making it easy to parse without unnecessary details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one optional parameter, no output schema), the description is minimally complete but lacks depth. It covers the basic purpose but doesn't address behavioral aspects like return format or usage context, which are important for an agent to invoke it correctly without annotations or output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'appKey' documented as 'Filter by specific app'. The description doesn't add any meaning beyond this, such as examples of app keys or how filtering works. With high schema coverage, the 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.
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 app connections'), making the purpose immediately understandable. It doesn't differentiate from sibling tools like 'get_available_apps' or 'create_connection', which would require more specificity about what distinguishes listing connections from other operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing existing connections, or compare it to siblings like 'get_available_apps' (which might list apps vs. connections). Without this context, usage is implied but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List workflow executions
| Name | Required | Description | Default |
|---|---|---|---|
| workflowId | No | Filter by workflow ID | |
| status | No | Filter by execution status | |
| limit | No | Limit number of results |
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. 'List workflow executions' implies a read-only operation but doesn't specify whether it returns all executions or requires pagination, what permissions are needed, or the format of returned data. For a tool with 3 parameters and no annotations, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient phrase that communicates the core purpose without any wasted words. It's perfectly front-loaded and appropriately sized for a simple listing tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a listing tool with good schema coverage but no annotations and no output schema, the description is minimally adequate. It identifies the resource type but doesn't provide context about what 'executions' entail, how results are structured, or important behavioral constraints. The schema handles parameter documentation, but overall context remains incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, clearly documenting all three parameters with their purposes and constraints. The description doesn't add any parameter information beyond what's in the schema, but since the schema is comprehensive, 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'List workflow executions' clearly states the verb ('List') and resource ('workflow executions'), making the purpose immediately understandable. It distinguishes this from sibling tools like 'list_workflows' or 'list_connections' by specifying the resource type. However, it doesn't specify scope or filtering capabilities, which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, when filtering is appropriate, or how it relates to sibling tools like 'get_workflow' or 'list_workflows'. The agent must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all workflows in Automatisch
| Name | Required | Description | Default |
|---|---|---|---|
| status | No | Filter workflows by status | |
| limit | No | Limit number of results |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure but only states the basic action. It doesn't mention whether this is a read-only operation, if it requires permissions, how results are ordered or paginated, or any rate limits. For a list 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence with zero waste—it states the purpose without unnecessary words. It's appropriately sized for a simple list tool and front-loaded with the core action, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of listing workflows (which may involve filtering, pagination, or permissions), the description is incomplete. With no annotations and no output schema, it fails to address key aspects like return format, error handling, or behavioral traits. It relies too heavily on the input schema alone, leaving gaps for an AI agent to infer usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with clear descriptions for both parameters ('status' and 'limit'), including an enum for 'status'. The description adds no additional parameter information beyond what the schema provides, so it meets the baseline of 3 where the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and resource ('all workflows in Automatisch'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'get_workflow' or 'list_executions', but the verb 'List all' suggests a comprehensive retrieval rather than fetching a single item or related executions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_workflow' for a single workflow or 'list_executions' for workflow runs. It lacks context about prerequisites, such as whether authentication is needed or if it's the primary method for browsing workflows.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Test a workflow with sample data
| Name | Required | Description | Default |
|---|---|---|---|
| workflowId | Yes | Workflow ID to test | |
| testData | No | Sample data for testing |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool tests a workflow with sample data, implying a read-only or simulation operation, but doesn't clarify if this is a dry run, if it affects production data, what permissions are needed, or what the output entails. This leaves significant gaps for a tool that likely executes workflows.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for the tool's complexity, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of testing workflows (which may involve execution and data handling), no annotations, and no output schema, the description is inadequate. It doesn't explain behavioral aspects like safety, output format, or error handling, leaving the agent with insufficient information for reliable use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters ('workflowId' and 'testData'). The description adds minimal value by implying 'testData' is sample data for testing, but doesn't provide additional context like format examples or constraints beyond what the schema states.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Test') and resource ('a workflow with sample data'), making the purpose understandable. It distinguishes this as a testing operation rather than creation, deletion, or listing, though it doesn't explicitly differentiate from sibling tools like 'list_executions' which might involve workflow execution.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing workflow), exclusions, or how it differs from related tools like 'list_executions' or 'update_workflow' in a testing context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update an existing workflow
| Name | Required | Description | Default |
|---|---|---|---|
| workflowId | Yes | Workflow ID to update | |
| name | No | New workflow name | |
| description | No | New workflow description | |
| active | No | Workflow active status |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states 'update' which implies mutation, but doesn't cover permissions needed, whether changes are reversible, side effects (e.g., on active workflows), or response format. For a mutation tool with zero annotation coverage, this is inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse. Every word earns its place, though it could benefit from additional context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (mutation with 4 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'update' entails behaviorally, potential impacts, or return values. For a tool that modifies workflows, more context is needed to guide safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 4 parameters (workflowId, name, description, active). The description adds no parameter-specific information beyond what the schema provides, such as format constraints or examples. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the action ('update') and resource ('existing workflow'), which is clear but basic. It doesn't differentiate from sibling tools like 'create_workflow' or 'delete_workflow' beyond the verb, and lacks specificity about what aspects can be updated. This is a minimal viable description that avoids tautology but provides no additional context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'create_workflow' or 'delete_workflow'. The description doesn't mention prerequisites (e.g., needing an existing workflow ID) or contextual cues for selection. This leaves the agent to infer usage solely from the tool name and schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
create_connectioncreate_workflowdelete_workflowget_available_appsget_workflowlist_connectionslist_executionslist_workflowstest_workflowupdate_workflowScored across 10 tools
Each tool has a clearly distinct purpose targeting specific resources and actions: connections, workflows, executions, and apps. There is no overlap or ambiguity, with tools like create_workflow, update_workflow, and delete_workflow covering different lifecycle stages without confusion.
All tools follow a consistent verb_noun pattern with snake_case throughout, such as create_connection, list_workflows, and update_workflow. The naming is predictable and uniform, making it easy for agents to understand and select tools.
With 10 tools, the count is well-scoped for managing workflows, connections, and executions in an automation platform. Each tool serves a clear purpose, such as CRUD operations for workflows and monitoring executions, without being excessive or insufficient.
The toolset provides strong coverage for core workflow management, including create, read, update, delete, list, and test operations, along with connection handling and execution monitoring. A minor gap exists in lacking tools for updating or deleting connections, but agents can still perform essential tasks effectively.
Give your AI agents the tools to build, manage, and run automation workflows.
Automate 1,000+ services from any MCP-compatible AI agent: build Applets, run actions and queries.
Zero-setup MCP gateway securely connecting AI to your tools with authentication and workflows
Create Tasks and run Workflows in Bleep from Claude, ChatGPT, and other AI assistants.
