Claude Code MCP - Agent Orchestration Platform

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation5/5
Each tool has a clearly distinct purpose with no overlap: create/delete for agents and sessions, status retrieval, listing, and message sending. The descriptions reinforce these boundaries, making it easy for an agent to select the right tool without confusion.
Naming Consistency5/5
All tools follow a consistent verb_noun pattern (e.g., create_agent, delete_session, get_session_status). The naming is uniform across all 7 tools, with no deviations in style or convention, ensuring predictability and readability.
Tool Count5/5
With 7 tools, the set is well-scoped for an agent orchestration platform. It covers core operations like session/agent lifecycle management, status monitoring, and communication, with each tool earning its place without being excessive or insufficient.
Completeness4/5
The toolset provides strong coverage for session and agent management, including CRUD operations and messaging. A minor gap exists in lacking tools for updating agent configurations or session properties, but agents can work around this by recreating resources as needed.
Average 3.3/5 across 7 of 7 tools scored. Lowest: 2.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is failing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the tool returns 'comprehensive status information' but doesn't specify what that includes (e.g., agent states, session metadata, timestamps) or behavioral traits like error handling, performance characteristics, or authentication requirements. The description is too vague for a mutation-free 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two sentences that are front-loaded: the first states the core purpose, and the second elaborates on the return value. There's minimal redundancy, though it could be slightly more efficient by combining ideas.
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 moderate complexity (status retrieval with one parameter), lack of annotations, and no output schema, the description is incomplete. It doesn't explain the return structure, error conditions, or parameter details, leaving significant gaps for an AI agent to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for undocumented parameters. It doesn't mention the session_id parameter at all, leaving its purpose, format, or sourcing unclear. The description adds no semantic value beyond what the bare schema provides, failing to address the coverage gap.
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 with specific verbs ('Get', 'Returns') and resources ('status of a session and its agents', 'comprehensive status information'). It distinguishes from siblings by focusing on status retrieval rather than creation, deletion, listing, or messaging. However, it doesn't explicitly differentiate from similar status-checking tools that might exist.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid session_id), compare to sibling tools like list_sessions for broader overviews, or specify use cases (e.g., monitoring agent activity). Usage is implied but not explicitly stated.
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 agent 'will receive the message and can respond accordingly,' which implies a communication flow but lacks details on permissions, rate limits, error handling, or whether this is a synchronous or asynchronous operation. 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two sentences that are front-loaded and avoid redundancy. The first sentence states the purpose clearly, and the second adds context without unnecessary elaboration. It could be slightly more structured but earns its place efficiently.
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 messaging between agents, no annotations, no output schema, and low schema coverage, the description is incomplete. It doesn't cover response formats, error cases, or integration with sibling tools like sessions, leaving the agent with insufficient context for reliable use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the schema provides no parameter descriptions. The description adds minimal semantics: it implies 'agent_name' identifies the recipient and 'message' is the content sent. However, it doesn't explain format constraints, valid agent names, or message handling, failing to compensate for the low 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: 'Send a message to a specific agent' and 'Delivers a message to the specified agent for processing.' It uses specific verbs ('send,' 'delivers') and identifies the resource ('agent'), but it doesn't differentiate from sibling tools like 'create_agent' or 'get_session_status,' which involve different operations on agents or sessions.
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 mentions that the agent 'can respond accordingly,' but this is vague and doesn't specify context, prerequisites, or exclusions. For example, it doesn't clarify if this is for real-time communication, asynchronous messaging, or how it relates to sessions or other agent interactions.
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 mentions initializing a session and preparing the environment for agent collaboration, which implies setup actions, but lacks details on permissions required, whether this is idempotent, what happens on failure, or any rate limits. For a creation 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two sentences that are front-loaded: the first states the purpose, and the second adds context about initialization and environment preparation. There's no wasted text, making it efficient, though it could be slightly more structured for clarity.
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 (creation operation with 2 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't cover what the tool returns (e.g., session ID, status), error conditions, or detailed behavioral aspects. For a tool that likely has side effects, this leaves the agent with insufficient information 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 0%, so the schema provides no parameter details. The description adds minimal semantics by mentioning 'specified root path' and implying session initialization, but it doesn't explain what root_path or session_name represent (e.g., file paths, identifiers), their formats, or constraints. This partially compensates for the lack of schema descriptions but falls short of fully clarifying parameter meanings.
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 creates a new development session for a project, specifying the action (create/initialize) and resource (session). It distinguishes from siblings like delete_session or get_session_status by focusing on creation rather than deletion or querying. However, it doesn't explicitly differentiate from create_agent, which might be a related but distinct operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether a project must exist), when not to use it (e.g., if a session already exists), or direct alternatives among siblings like list_sessions for checking existing sessions. Usage is implied but not explicitly stated.
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 states the tool returns 'a summary of all currently active sessions' but doesn't specify what 'basic information' or 'summary' includes, whether there are pagination limits, rate limits, authentication requirements, or what 'active' means in this context. The description provides minimal behavioral context beyond the basic operation.
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 two clear sentences that directly state the tool's function. The first sentence establishes the core purpose, and the second reinforces it without redundancy. There's no wasted language, though it could be slightly more front-loaded by combining the two sentences.
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 simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It explains what the tool does at a high level but lacks details about the return format, what constitutes 'active' sessions, or how this differs from related session management tools. For a read-only listing operation, more context about the output would be helpful since there's no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't discuss parameters since none exist, and it correctly focuses on what the tool does rather than trying to explain non-existent inputs.
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 ('List') and resource ('all active sessions and their basic information'), making the tool's purpose explicit. It distinguishes from siblings like 'get_session_status' by focusing on listing all active sessions rather than checking a specific session. However, it doesn't explicitly differentiate from other list-like operations that might exist in the broader context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to prefer 'list_sessions' over 'get_session_status' for checking individual sessions, or how it relates to session creation/deletion tools. There's no context about prerequisites, timing, or exclusion criteria.
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. It states this is a creation operation but doesn't disclose behavioral traits like required permissions, whether this is idempotent, what happens on duplicate agent names, rate limits, or what the response contains. 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core purpose. The second sentence adds useful context about configuration and assignment. No wasted words, though it could be slightly more structured with bullet points for parameters given the low schema coverage.
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 mutation tool with 4 parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns, error conditions, or detailed parameter meanings. Given the complexity and lack of structured data, the description should provide more comprehensive guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate but adds minimal parameter semantics. It mentions 'specified configuration' vaguely but doesn't explain what the 4 parameters mean, their relationships, or constraints. The description doesn't clarify what 'specialization' or 'system_prompt_suffix' do, leaving parameters largely undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Create') and resource ('new Claude Code agent') with specific context ('within a managed session'). It distinguishes from siblings like 'create_session' (creates session vs agent) and 'delete_agent' (destructive vs constructive). The purpose 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.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context ('within a managed session', 'for collaborative development work') but doesn't explicitly state when to use this vs alternatives like 'create_session' or prerequisites. It mentions assignment to a session but lacks explicit guidance on when-not-to-use or comparison with sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'Safely terminates and removes an agent from its session,' which implies a destructive operation with some safety measures, but it does not detail permissions required, irreversible consequences, error conditions, or what happens to associated resources. The force parameter behavior is noted, but overall behavioral context is incomplete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by behavioral and parameter details in two concise sentences. Every sentence adds value: the first states the action, the second describes safety and the force parameter. There is no wasted text, and the structure is efficient.
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 complexity (destructive operation with 2 parameters), no annotations, and no output schema, the description is moderately complete. It covers the basic purpose and force parameter usage but lacks details on permissions, error handling, return values, and full parameter semantics. It meets minimum viability but has clear gaps for a deletion tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains the purpose of the force parameter ('to forcefully terminate unresponsive agents'), adding meaningful context beyond the schema's boolean type. However, it does not clarify the agent_name parameter's format or constraints. The description partially compensates but leaves one parameter undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Delete') and target resource ('an agent from the system'), distinguishing it from sibling tools like delete_session (which targets sessions) and create_agent (which creates rather than deletes). The verb+resource combination is precise and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the force parameter ('to forcefully terminate unresponsive agents'), but it does not explicitly state when to use this tool versus alternatives like delete_session or when deletion is appropriate versus other operations. The guidance is helpful but lacks sibling differentiation and exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's behavior: 'Safely terminates all agents in the session and cleans up resources' explains the destructive nature and cleanup process, while the force parameter guidance addresses handling of unresponsive sessions. It doesn't mention error conditions, permissions, or rate limits, but provides solid core behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences with zero waste: the first states the purpose, the second explains the safe behavior, the third provides parameter guidance. Each sentence earns its place, and the structure is front-loaded with the core action followed by important details.
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?
For a destructive tool with no annotations and no output schema, the description provides adequate but incomplete context. It covers the main behavior and parameter usage but lacks information about return values, error conditions, permissions required, or what happens if the session doesn't exist. Given the complexity of session/agent management, more completeness would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must compensate for the lack of parameter documentation. It does this well by explaining the purpose of the force parameter ('to forcefully terminate unresponsive sessions') and implying session_id identifies the target session. While it doesn't detail session_id format or constraints, it provides meaningful semantic context beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Delete a session and all its agents') and distinguishes it from sibling tools like delete_agent (which deletes individual agents) and list_sessions/get_session_status (which are read-only). The verb+resource combination is precise and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the force parameter ('to forcefully terminate unresponsive sessions'), which implicitly suggests when to use the default (force=False) for normal termination. However, it doesn't explicitly state when to choose this tool over alternatives like delete_agent or provide prerequisites for session deletion.
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:

[![Claude_Code_MCP_2 MCP server](https://glama.ai/mcp/servers/Nexus-Digital-Automations/Claude_Code_MCP_2/badges/card.svg)](https://glama.ai/mcp/servers/Nexus-Digital-Automations/Claude_Code_MCP_2)

Score Badge

Copy to your README.md:

[![Claude_Code_MCP_2 MCP server](https://glama.ai/mcp/servers/Nexus-Digital-Automations/Claude_Code_MCP_2/badges/score.svg)](https://glama.ai/mcp/servers/Nexus-Digital-Automations/Claude_Code_MCP_2)

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/Nexus-Digital-Automations/Claude_Code_MCP_2'

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