Click on "Install 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., "@Back-Agent MCP Server create a React component for a login form with validation"
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.
An MCP (Model Context Protocol) server that executes development tasks using Claude Code CLI.
Execute tasks through Claude Code CLI via MCP protocol
Non-interactive mode by default (-p flag auto-applied)
Specify custom working directories
Configurable timeout settings
Comprehensive error handling and logging
Related MCP server: Claude Code Connector MCP
Node.js >= 18
Claude Code CLI installed and available in PATH
# Clone the repository
git clone <repository-url>
cd back-agent-mcp
# Install dependencies
npm install
# Build the project
npm run build# Development mode (with tsx)
npm run dev
# Production mode (built)
npm startnpm install @zuens2020/back-agent-mcpAdd the following to your Claude Desktop configuration file:
Windows: %APPDATA%\Claude\claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json
{
"mcpServers": {
"back-agent": {
"command": "node",
"args": ["--experimental-modules", "C:\\Users\\YourUsername\\AppData\\Roaming\\npm\\node_modules\\@zuens2020\\back-agent-mcp\\dist\\index.js"]
}
}
}Or using npx:
{
"mcpServers": {
"back-agent": {
"command": "npx",
"args": ["-y", "@zuens2020/back-agent-mcp"]
}
}
}Executes a development task using Claude Code CLI.
Parameters:
Name | Type | Required | Description |
| string | Yes | The task description to execute |
| string | No | Working directory for execution |
| number | No | Timeout in seconds (max 3600, default 300) |
| string[] | No | Additional CLI arguments (excluding |
Example:
{
"task": "Create a function that calculates fibonacci numbers",
"workingDirectory": "C:\\Projects\\my-app",
"timeout": 600
}# Type checking
npm run typecheck
# Build
npm run build
# Development mode
npm run devsrc/
├── index.ts # Main entry point
├── server/
│ └── tools/
│ └── execute-task.ts # Task execution tool
├── claude/
│ └── executor.ts # Claude Code CLI executor
└── utils/
├── logger.ts # Logging utilities
└── error-handler.ts # Error handlingVariable | Description | Values |
| Set logging verbosity |
|
MIT
Cancel a pending or running task.
| Name | Required | Description | Default |
|---|---|---|---|
| taskId | Yes | The task ID |
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 cancels tasks, implying a mutation operation, but lacks details on permissions needed, whether cancellation is reversible, side effects (e.g., on related resources), or error conditions. This is a significant gap for a mutation tool 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 a single, efficient sentence with zero waste. It is appropriately sized and front-loaded, clearly stating the tool's purpose without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a mutation operation), lack of annotations, and no output schema, the description is incomplete. It fails to address key contextual aspects like behavioral traits, usage scenarios, or what to expect upon cancellation, leaving significant gaps for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents the single parameter 'taskId'. The description adds no additional meaning 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('cancel') and target ('a pending or running task'), providing a specific verb+resource combination. It distinguishes the tool's purpose from siblings like 'delete-task' (removal) or 'execute-task' (initiation), though it doesn't explicitly mention these distinctions in the text.
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 'delete-task' or 'execute-task'. It mentions 'pending or running' tasks, which implies a context, but offers no explicit when/when-not rules, prerequisites, or named alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
IMPORTANT: This creates a background task for an AI programming assistant, NOT a direct shell command executor.
Spawns Claude Code (an AI coding agent) as a subprocess to complete development tasks in the background. Claude Code will interpret your natural language request and autonomously decide which actions to take.
What it does:
Creates a non-blocking background task
Returns task ID immediately for tracking
Up to 3 tasks run concurrently by default
What it does NOT do:
NOT a direct shell/bash command executor
Does NOT return raw stdout/stddr from commands
Returns a task ID. Use get-task-status to check progress and get-task-result to retrieve the output.
| Name | Required | Description | Default |
|---|---|---|---|
| task | Yes | Natural language task description for Claude Code AI. This is NOT a direct shell command executor. Claude Code is an AI programming assistant that will interpret your request and use its own tools (Read, Edit, Bash, etc.) to complete the task. Example: "Create a README file" or "Fix the bug in login.js" or "Run the tests and report results" | |
| workingDirectory | No | The working directory for execution. Defaults to the current workspace directory if not specified. | |
| timeout | No | Timeout in seconds (max 3600) | |
| additionalArgs | No | Additional CLI arguments |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and delivers substantial behavioral context. It discloses key traits: creates non-blocking background tasks, returns task ID immediately, allows up to 3 concurrent tasks by default, and clarifies what it doesn't do (no direct shell execution, no raw stdout/stderr). However, it doesn't mention error handling, retry behavior, or resource constraints beyond concurrency limits.
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 well-structured with clear sections (IMPORTANT warning, What it does, What it does NOT do) and every sentence adds value. It's appropriately sized for a complex tool but could be slightly more concise by integrating some repetitive elements about not being a shell executor. The front-loaded warning is particularly effective.
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 complex tool with no annotations and no output schema, the description provides substantial context about behavior, limitations, and integration with sibling tools. It explains the return value (task ID) and how to use it with other tools. The main gap is lack of information about error responses or what happens when concurrency limits are exceeded, but overall it's quite complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description doesn't add meaningful parameter semantics beyond what's in the schema - it mentions 'natural language task description' and 'background task' but these are already covered in the schema's task parameter description. The baseline of 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 explicitly states what the tool does: 'Spawns Claude Code (an AI coding agent) as a subprocess to complete development tasks in the background.' It clearly distinguishes from sibling tools by emphasizing it's NOT a direct shell command executor (unlike execute-task) and specifies it creates background tasks that require get-task-status/result for monitoring (unlike list-tasks or get-task-stats). The verb+resource combination is specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 versus alternatives. It states 'NOT a direct shell command executor' (contrasting with execute-task), specifies it's for 'background tasks' with natural language requests, and directs users to use get-task-status and get-task-result for tracking and retrieval. The 'What it does NOT do' section clearly sets boundaries against misuse.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Delete a task from the task list. Use this to clean up old completed tasks.
| Name | Required | Description | Default |
|---|---|---|---|
| taskId | Yes | The task ID |
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 action is for deletion but doesn't cover critical aspects like whether this is reversible, what permissions are required, if it affects related data, or what the response looks like. For a destructive operation 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 brief and to the point with two sentences, front-loading the core purpose. Every sentence adds value: the first states the action, and the second provides usage context. It could be slightly more structured by explicitly separating purpose from guidelines, but it's efficient with minimal waste.
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 as a destructive operation with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., irreversibility, permissions), response format, and error handling. For a delete tool, this leaves significant gaps in understanding how to use it effectively.
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 'taskId' clearly documented as 'The task ID.' The description doesn't add any extra meaning about the parameter beyond what the schema provides, such as format examples or constraints. Since the schema does the heavy lifting, 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 clearly states the action ('Delete') and resource ('a task from the task list'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from sibling tools like 'cancel-task' or explain how deletion differs from cancellation, 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 some guidance with 'Use this to clean up old completed tasks,' which implies a context for usage. However, it doesn't specify when NOT to use it (e.g., for active tasks vs. completed ones) or mention alternatives like 'cancel-task' for different scenarios, leaving usage somewhat implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
IMPORTANT: This is an AI programming assistant tool, NOT a direct shell command executor.
This tool spawns Claude Code (an AI coding agent) as a subprocess to complete development tasks. Claude Code will interpret your natural language request and autonomously decide which actions to take (reading files, editing code, running commands, etc.) to accomplish the goal.
What it does:
Accepts natural language task descriptions
Claude Code AI figures out how to complete the task
Returns the AI's response and actions taken
What it does NOT do:
NOT a direct shell/bash command executor
Does NOT return raw stdout/stderr from commands
For direct command execution, use the Bash tool instead
Example usage:
"Create a REST API endpoint for user authentication"
"Debug why the tests are failing"
"Refactor the user module to use TypeScript"
The returned output is Claude Code's conversational response, not raw command output.
| Name | Required | Description | Default |
|---|---|---|---|
| task | Yes | Natural language task description for Claude Code AI. This is NOT a direct shell command executor. Claude Code is an AI programming assistant that will interpret your request and use its own tools (Read, Edit, Bash, etc.) to complete the task. Example: "Create a README file" or "Fix the bug in login.js" or "Run the tests and report results" | |
| workingDirectory | No | The working directory for Claude Code execution. Defaults to the current workspace directory if not specified. | |
| timeout | No | Timeout in seconds (max 3600) | |
| additionalArgs | No | Additional CLI arguments for Claude Code |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: that it spawns an AI subprocess, returns conversational responses rather than raw command output, and that Claude Code autonomously decides actions. It could be improved by mentioning potential side effects or limitations, but covers the core behavior well.
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 well-structured with clear sections (IMPORTANT disclaimer, what it does, what it does NOT do, example usage). While slightly verbose, each section serves a clear purpose. The information is front-loaded with the critical disclaimer about not being a direct shell executor. Minor trimming could improve conciseness without losing value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description provides substantial context about behavior, limitations, and appropriate usage. It explains the AI agent nature, return format, and key constraints. The main gap is lack of information about the output structure, but given the complexity of the tool, the description does a commendable job of providing necessary context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal parameter-specific information beyond what's in the schema - it mentions 'natural language task descriptions' which aligns with the 'task' parameter, but doesn't provide additional semantic context for other parameters. Baseline 3 is appropriate given the comprehensive schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs and resources: 'spawns Claude Code (an AI coding agent) as a subprocess to complete development tasks' and 'accepts natural language task descriptions.' It explicitly distinguishes from sibling tools by contrasting with 'direct shell command executor' and naming the Bash tool as an alternative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool versus alternatives: 'NOT a direct shell command executor' and 'For direct command execution, use the Bash tool instead.' It includes clear examples of appropriate usage scenarios and explicitly states what it does NOT do, helping users choose between this and sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the full result of a task including stdout/stderr output. Only available for completed tasks.
| Name | Required | Description | Default |
|---|---|---|---|
| taskId | Yes | The task ID |
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 adds useful context about availability for completed tasks, which isn't obvious from the schema. However, it doesn't describe other behavioral traits like error handling (e.g., what happens if the task isn't completed), response format details, or potential limitations (e.g., size constraints on output).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two concise sentences that front-load the core purpose and follow with a critical usage constraint. Every sentence earns its place by providing essential information without redundancy or unnecessary elaboration, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (retrieving task results), lack of annotations, and no output schema, the description is somewhat complete but has gaps. It covers the purpose and a key constraint, but doesn't explain the return values (e.g., structure of stdout/stderr) or other behavioral aspects, leaving the agent with incomplete 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%, with the parameter 'taskId' fully documented in the schema as 'The task ID'. The description doesn't add any additional meaning about parameters 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 doesn't need to.
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 'full result of a task including stdout/stderr output', making the purpose specific and understandable. It distinguishes from siblings like 'get-task-status' by specifying it retrieves the complete output rather than just status information. However, it doesn't explicitly contrast with all siblings (e.g., 'get-task-stats'), 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 clear context with 'Only available for completed tasks', which helps determine when to use this tool versus alternatives like 'get-task-status' for pending tasks. It doesn't explicitly name alternatives or provide exclusions for other scenarios, but the completion requirement offers practical guidance for appropriate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get statistics about all tasks.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
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 'Get statistics about all tasks', which implies a read-only operation, but doesn't specify what kind of statistics (e.g., counts, averages, trends), whether it requires permissions, or how data is returned (e.g., format, pagination). This leaves significant gaps in understanding the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence: 'Get statistics about all tasks.' It is front-loaded and wastes no words, making it easy to parse quickly. Every word earns its place by conveying the core action and scope.
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 statistical tools and the lack of annotations and output schema, the description is incomplete. It doesn't explain what statistics are returned (e.g., numerical summaries, charts), how they are aggregated, or any limitations. For a tool that likely provides detailed data, this minimal description fails to give enough context for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate here, but it could have clarified that no inputs are required. Baseline is 4 for zero parameters, as the schema fully covers the absence of inputs.
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 'Get statistics about all tasks' clearly states the verb ('Get') and resource ('statistics about all tasks'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get-task-status' or 'get-task-result', leaving ambiguity about what specific statistics are provided versus status or result information.
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. With siblings like 'get-task-status', 'get-task-result', and 'list-tasks', there's no indication of whether this tool is for aggregated metrics, performance data, or other statistical insights, nor any prerequisites or exclusions mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the current status of a task. Returns status, timestamps, and basic info.
| Name | Required | Description | Default |
|---|---|---|---|
| taskId | Yes | The task ID |
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 the tool returns status, timestamps, and basic info, but doesn't disclose behavioral traits such as required permissions, error handling (e.g., if taskId is invalid), rate limits, or whether it's a read-only operation (implied by 'Get' but not explicit). This leaves 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences that are front-loaded with the core purpose and return details. Every word earns its place with no redundancy or unnecessary elaboration, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one parameter, no output schema, no annotations), the description covers the basic purpose and return information adequately. However, it lacks details on behavioral aspects like error cases or permissions, which are important for a status-checking tool in a task management context with multiple sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'taskId' documented as 'The task ID'. The description adds no additional meaning beyond this, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate as the schema handles 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 'Get' and resource 'current status of a task', specifying what information is returned (status, timestamps, basic info). It distinguishes from siblings like 'get-task-result' (which likely returns task output) and 'get-task-stats' (which likely returns aggregated metrics), though the differentiation isn't explicit.
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 'get-task-result' (for results) or 'list-tasks' (for multiple tasks). The description implies usage for checking a specific task's status but doesn't mention prerequisites, exclusions, or comparisons with sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all tasks, optionally filtered by status.
| Name | Required | Description | Default |
|---|---|---|---|
| status | No | Filter by status (optional) | |
| limit | No | Maximum number of tasks to return (default: 50) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions optional filtering but doesn't disclose important behavioral traits like pagination behavior (implied by 'limit' parameter), default sorting, whether it returns all tasks or only those accessible to the user, or any rate limits. The description is minimal and lacks necessary operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a simple list operation and front-loads the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a list operation with no annotations and no output schema, the description is insufficient. It doesn't explain what information is returned about each task, how results are structured, or important operational constraints. Given the context of multiple sibling tools for task management, more guidance is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents both parameters with descriptions and enum values. The description adds no additional parameter semantics beyond what's in the schema, meeting the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('tasks') with optional filtering by status. It's specific about what the tool does, though it doesn't explicitly differentiate from sibling tools like 'get-task-stats' or 'get-task-status' which might also retrieve task information.
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. With siblings like 'get-task-stats', 'get-task-status', and 'get-task-result', there's no indication of when this list operation is preferred over those more specific retrieval tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
There is significant overlap between create-task and execute-task, both described as spawning Claude Code AI for development tasks with similar capabilities and limitations, which could cause confusion. However, other tools like cancel-task, delete-task, get-task-result, get-task-status, list-tasks, and get-task-stats have clearer distinct purposes related to task management.
Tool names follow a consistent verb-noun pattern with hyphens (e.g., create-task, get-task-status), making them predictable and readable. The only minor deviation is execute-task, which uses a different verb than the others but still fits the pattern.
With 8 tools, the server is well-scoped for task management and AI programming assistance. Each tool has a clear role, such as creating, executing, monitoring, and managing tasks, which fits the server's purpose without being overly sparse or bloated.
The tool set covers the full lifecycle of tasks (create, execute, status, result, cancel, delete, list, stats), providing good coverage for task management. A minor gap is the lack of tools for updating or modifying tasks, but agents can work around this by recreating tasks if needed.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Source-checked CLI guides and model-aware planning for Claude Code, Codex, and Grok Build.
Claude Code / MCP skills for the dev pipeline: discover, spec, design, build, ship, operate.
Build, deploy and manage MaShop e-commerce projects from Claude, Cursor or any MCP client.
Live SEO workflow tools for Claude Code, Codex, and AI agents.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/ZUENS2020/back-agent-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
