Motion MCP Server

Server Quality Checklist

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

Latest release: v2.6.0
Disambiguation5/5
Each tool has a clearly distinct purpose targeting specific Motion resources like comments, custom_fields, projects, recurring_tasks, schedules, search, statuses, tasks, users, and workspaces. There is no overlap in functionality, making it easy for an agent to select the correct tool for any operation.
Naming Consistency5/5
All tools follow a consistent 'motion_' prefix with a descriptive noun (e.g., motion_comments, motion_custom_fields, motion_projects). This uniform naming pattern enhances predictability and readability across the entire tool set.
Tool Count5/5
With 10 tools, the server is well-scoped for managing Motion's project and task management domain. Each tool covers a distinct aspect (e.g., tasks, projects, users, custom fields), ensuring comprehensive coverage without being overwhelming or sparse.
Completeness5/5
The tool set provides complete CRUD/lifecycle coverage for Motion's core resources, including tasks (create, list, get, update, delete, move, unassign), projects (create, list, get), and supporting operations like custom fields, comments, users, workspaces, and search. There are no obvious gaps that would hinder agent workflows.
Average 2.9/5 across 10 of 10 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- No commit activity data available
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under Apache 2.0.
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?
No annotations are provided, so the description carries full burden. 'Manage comments' implies both read and write capabilities, but it doesn't disclose behavioral traits like authentication needs, rate limits, pagination behavior for list operations, or side effects of create operations. The description is minimal and fails to add meaningful context beyond the basic operation verbs.
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 extremely concise—a single phrase—and front-loaded with the core purpose. However, it's arguably too brief, bordering on under-specified rather than efficiently informative. It earns points for zero waste but loses one point for lacking necessary elaboration given the tool's complexity.
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 no annotations, no output schema, and a multi-operation tool with four parameters, the description is incomplete. It doesn't cover return values, error conditions, or operational nuances. The agent must rely heavily on the input schema and trial-and-error, making this inadequate for a tool with moderate complexity.
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 all parameters. The description adds no parameter semantics beyond what's in the schema—it doesn't explain relationships (e.g., content is only for create), constraints, or examples. Baseline 3 is appropriate as the schema does the heavy lifting, but the description doesn't compensate or enhance understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Manage comments on tasks' states the general purpose (verb+resource) but is vague about what 'manage' entails. It doesn't distinguish this tool from potential sibling comment tools (though none are listed), and 'manage' could encompass various operations beyond just list/create. The description provides basic orientation but lacks specificity.
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. The description doesn't mention prerequisites, context for choosing between list/create operations, or how it relates to sibling tools like motion_tasks. Usage is implied through parameter names but not explicitly stated, leaving the agent to infer from the schema alone.
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 full burden for behavioral disclosure. It implies read operations ('get current user information') and possible write operations ('manage users'), but doesn't clarify what 'manage' means (e.g., permissions required, side effects, rate limits). This is a significant gap for a tool that could involve mutations, leaving the agent uncertain about 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. However, it could be more structured by separating the two distinct operations (list vs. current) for clarity, and 'manage users' is somewhat ambiguous, slightly reducing conciseness.
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 complexity of a tool with multiple operations (including potential mutations) and no annotations or output schema, the description is incomplete. It fails to explain behavioral traits, usage context, or return values, making it inadequate for an agent to confidently invoke the tool without guesswork.
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 all 4 parameters (operation, workspaceId, workspaceName, teamId) with descriptions and constraints. The description adds no additional meaning beyond what the schema provides, such as explaining how 'manage' relates to the operation parameter. 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.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Manage users and get current user information' states a general purpose but is vague about what 'manage' entails (e.g., create, update, delete) and doesn't specify the resource scope (e.g., workspace users). It distinguishes from siblings like motion_tasks or motion_projects by focusing on users, but lacks specificity compared to a more precise verb+resource statement.
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. The description mentions two operations ('manage users' and 'get current user information'), but it doesn't explain when to choose list vs. current, or how it relates to other user-related tools (none listed as siblings). This leaves the agent without explicit context for selection.
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 full burden for behavioral disclosure. It mentions the supported operations but doesn't describe what 'manage' entails beyond listing them. It omits critical details like authentication requirements, rate limits, error conditions, or what the operations actually return (especially problematic without an 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. It wastes no words, though it could be slightly more structured by explicitly separating the operations or adding minimal context.
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 (7 parameters, 3 operations) and lack of annotations and output schema, the description is insufficient. It doesn't explain return values, error handling, or operational nuances, leaving significant gaps for an AI agent to understand how to use it effectively.
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 7 parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema, but since the schema coverage is high, 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 as managing Motion projects with specific operations (create, list, get). It uses a specific verb ('manage') and resource ('Motion projects'), but doesn't distinguish it from sibling tools like motion_tasks or motion_workspaces that might also manage related resources.
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 sibling tools like motion_search or motion_tasks that might overlap in functionality, nor does it specify prerequisites or constraints for the operations.
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 full burden for behavioral disclosure. It mentions 'search' but doesn't clarify whether this is a read-only operation, what authentication is required, how results are returned (format, pagination), or any rate limits. For a search tool with 6 parameters, this leaves significant behavioral aspects undocumented.
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 gets straight to the point with zero wasted words. It's appropriately sized for a search tool and front-loads the essential information about what the tool does.
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?
For a search tool with 6 parameters, no annotations, and no output schema, the description is insufficiently complete. It doesn't explain what kind of search this performs (full-text, filtered), how results are structured, or provide any behavioral context. The agent would need to rely heavily on the schema alone without guidance on proper usage.
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 all parameters are documented in the schema itself. The description adds no additional parameter information beyond what's in the schema - it doesn't explain the relationship between workspaceId and workspaceName, clarify searchScope behavior, or provide query syntax examples. 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Search') and resource ('Motion tasks and projects'), making the purpose immediately understandable. However, it doesn't differentiate this search tool from other Motion tools like motion_tasks or motion_projects, which might also retrieve task/project data through different mechanisms.
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. With multiple sibling tools like motion_tasks and motion_projects that might retrieve similar data, there's no indication whether this search tool is for full-text search, filtered queries, or specific use cases. No exclusions or prerequisites are mentioned.
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 action ('Get') but does not describe traits like whether this is a read-only operation, potential rate limits, authentication needs, or the format of returned data. This is a significant gap 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is 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.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It does not explain what 'statuses' include (e.g., types, values), how results are structured, or any error conditions, leaving gaps in understanding for effective tool invocation.
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 'workspaceId' documented as optional. The description adds no additional meaning beyond the schema, such as explaining what 'statuses' entail or how they are used, so it meets the baseline for high schema coverage without compensating value.
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 verb ('Get') and resource ('available task/project statuses for a workspace'), making the purpose understandable. However, it does not explicitly differentiate this tool from siblings like 'motion_custom_fields' or 'motion_projects', which might also retrieve workspace-related data, so it misses the highest score.
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 does not mention sibling tools or specific contexts for usage, such as when statuses are needed versus other workspace data, leaving the agent without clear direction.
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. While it lists operations, it doesn't describe what each operation does, their effects (e.g., delete is destructive), authentication requirements, rate limits, error handling, or response formats. For a multi-operation tool with 19 parameters, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise - a single sentence that efficiently lists all supported operations. It's front-loaded with the core purpose and wastes no words. Every element (the verb, resource, and operation list) earns its place.
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?
For a complex tool with 19 parameters, 8 distinct operations, no annotations, and no output schema, the description is inadequate. It doesn't explain what the tool returns, how operations differ, error conditions, or provide any behavioral context. The single-sentence description fails to address the tool's complexity despite good schema documentation.
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 description provides no parameter-specific information beyond listing operations. However, the input schema has 100% description coverage with detailed parameter documentation, including operation-specific requirements and usage notes. The description adds no value beyond what's already 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.
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 as managing Motion tasks with specific operations (create, list, get, update, delete, move, unassign, list_all_uncompleted). It provides a verb ('manage') and resource ('Motion tasks'), but doesn't differentiate from sibling tools like motion_projects or motion_workspaces that might also manage related entities.
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 when to choose motion_tasks over sibling tools like motion_search for searching tasks, motion_recurring_tasks for recurring tasks, or motion_comments for task comments. No context about prerequisites or exclusions is provided.
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 'manage' and 'supports list and get operations,' implying read-only or retrieval functions, but doesn't clarify if 'manage' includes mutations (e.g., create/update/delete), which could be misleading. It lacks details on permissions, rate limits, or response formats, leaving 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise and front-loaded: a single sentence that directly states the tool's purpose and supported operations. There's no wasted language or redundancy, making it efficient for an agent to parse 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 (managing workspaces with multiple operations), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like authentication requirements, error handling, or what data is returned, which are crucial for effective tool invocation. This leaves the agent with insufficient context to use the tool reliably.
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 ('operation' and 'workspaceId') with descriptions and enum values. The description adds no additional meaning beyond what's in the schema, such as explaining the context of 'list' vs. 'get' operations or workspace ID formats. Baseline 3 is appropriate as the schema handles the heavy lifting.
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: 'Manage Motion workspaces - supports list and get operations.' It specifies the verb ('manage') and resource ('Motion workspaces'), and details the supported operations. However, it doesn't explicitly differentiate from sibling tools like 'motion_projects' or 'motion_users', which might also manage related resources, keeping it from 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.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides minimal guidance: it mentions 'list and get operations' but doesn't specify when to use this tool versus alternatives like 'motion_search' or other sibling tools. There's no context on prerequisites, such as authentication needs or workspace access, leaving the agent with little direction on appropriate usage scenarios.
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 describes the required parameters per operation, which gives some behavioral context, but fails to disclose critical traits like whether operations are read-only or destructive, authentication needs, rate limits, error handling, or what the tool returns. For a tool with 7 operations including create/delete, 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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized but poorly structured as a single run-on sentence with comma-separated operation lists. It's front-loaded with the core purpose, but the parameter requirements could be better organized (e.g., bullet points or clearer separation). Some redundancy exists with schema information.
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 (12 parameters, 7 operations, no annotations, no output schema), the description is incomplete. It covers parameter requirements but misses behavioral context, return values, error conditions, and operational constraints. For a multi-operation tool managing custom fields, this leaves 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.
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 12 parameters thoroughly. The description adds minimal value by listing required parameters per operation, but doesn't provide additional semantic context beyond what's in the schema descriptions (e.g., explaining what 'field' types mean in practice or how 'valueId' differs from 'fieldId'). 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.
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 as 'Manage custom fields for tasks and projects' with a specific verb ('manage') and resource ('custom fields'), distinguishing it from sibling tools like motion_tasks or motion_projects. However, it doesn't explicitly differentiate from all siblings (e.g., motion_statuses could also involve field management).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage guidance through the enumeration of required parameters per operation, which helps understand when to use each operation. However, it lacks explicit when-to-use or when-not-to-use statements, and doesn't mention alternatives among sibling tools (e.g., when to use this vs. motion_tasks for task-related operations).
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 API returns all schedules without filtering, which is useful behavioral context, but it doesn't cover other traits like authentication requirements, rate limits, error handling, or response format. The description adds some value but leaves significant gaps in transparency 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 concise with two sentences that are front-loaded with the core purpose. It avoids unnecessary details, but the second sentence could be slightly more integrated (e.g., 'This tool retrieves all schedules, including weekly working hours and time zones, with no filtering options available.'). Overall, it's efficient with minimal waste.
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 by stating what it does and a key limitation. However, it lacks details on output (e.g., format or structure of returned schedules) and doesn't fully address behavioral aspects like error cases or integration with siblings, making it adequate but with clear gaps for a tool with no structured support.
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 single parameter 'operation' documented as 'Operation to perform' and an enum of ['list']. The description doesn't add any meaning beyond this, such as explaining why the parameter exists or its implications. Since schema coverage is high, 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('all schedules') with specific attributes ('weekly working hours and time zones'), making the purpose understandable. However, it doesn't explicitly differentiate this tool from potential sibling tools like 'motion_search' or 'motion_projects' that might also retrieve schedule-related data, preventing 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.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides minimal guidance by noting 'no filtering options,' which implies when not to use it for filtered queries, but it lacks explicit alternatives (e.g., 'use motion_search for filtered results') or context on when to prefer this tool over others like 'motion_workspaces' or 'motion_users' for schedule-related needs. No clear usage scenarios or prerequisites are mentioned.
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. While it mentions required parameters per operation, it doesn't disclose important behavioral traits: whether create/delete operations are destructive, what permissions are needed, what the response format looks like, or any rate limits. For a tool with write operations and no 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with a single sentence that efficiently communicates the core functionality and parameter requirements per operation. It's front-loaded with the main purpose and wastes no words. However, it could be slightly more structured by separating the purpose from the parameter requirements.
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 (15 parameters, nested objects, write operations) and the absence of both annotations and an output schema, the description is insufficient. It doesn't explain what the tool returns, what happens when operations succeed/fail, or important behavioral constraints. For a multi-operation tool with create/delete capabilities, this leaves critical gaps for an AI 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?
The schema description coverage is 100%, so the schema already documents all 15 parameters thoroughly. The description adds minimal value beyond the schema by listing which parameters are required for each operation. However, it doesn't provide additional semantic context about parameter relationships or usage patterns that aren't already in the schema descriptions.
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: 'Manage recurring tasks' with specific operations (list, create, delete). It distinguishes itself from sibling tools like motion_tasks by focusing on recurring tasks specifically. However, it doesn't explicitly contrast with motion_tasks which might handle non-recurring tasks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear guidance on when to use each operation by specifying required parameters per operation (e.g., 'list: workspaceId or workspaceName'). This helps the agent understand which parameters are needed for each use case. However, it doesn't explicitly mention when NOT to use this tool or direct users to alternatives like motion_tasks for non-recurring tasks.
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:

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

Score Badge

Copy to your README.md:

[![motion-mcp-server MCP server](https://glama.ai/mcp/servers/sergiolopez94/motion-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/sergiolopez94/motion-mcp-server)

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/sergiolopez94/motion-mcp-server'

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