Enables routing and execution of hardware-related tasks on nodes equipped with Arduino connectivity and capabilities.
Automatically offloads and executes Docker container commands, builds, and management tasks across distributed cluster nodes.
Distributes Jest test suites across the cluster for parallel execution and improved testing throughput.
Provides distributed command execution and task routing specifically targeting x86_64 Linux nodes within the cluster.
Routes and executes commands across macOS-based nodes, supporting both Intel and ARM64 architectures for distributed tasks.
Automatically routes and executes Mocha-based test suites across optimal cluster nodes.
Offloads Node.js package management and build tasks to the most suitable nodes in the distributed network.
Routes LLM inference and model-serving workloads to dedicated inference nodes running Ollama.
Automatically routes pnpm build and installation commands to optimal nodes based on current cluster load.
Supports distributed execution of Podman container operations and builds across the node network.
Enables parallel and distributed execution of Python test suites via pytest across the agentic cluster.
Routes Swift compilation and build tasks to macOS nodes within the cluster.
Supports routing orchestration and coordination tasks to cluster nodes configured with Temporal.
Supports execution of commands and containerized workloads specifically targeting Ubuntu environments on Linux nodes.
Automatically offloads Yarn-based build processes and package management tasks to available cluster resources.
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., "@Cluster Execution MCP Server run my test suite in parallel across the cluster nodes"
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.
Cluster-aware command execution for distributed task routing across the AGI agentic cluster.
Version: 0.2.0
Automatic task routing: Commands routed to optimal nodes based on load, capabilities, and requirements
Multi-node support: macpro51 (Linux x86_64), mac-studio (macOS ARM64), macbook-air (macOS ARM64), inference node
Dynamic IP resolution: mDNS, DNS, and fallback methods with caching
Security hardened: No shell injection, environment-based configuration, command validation
SSH connectivity verification: Retry logic with configurable timeouts
Parallel execution: Distribute commands across cluster for maximum throughput
Related MCP server: remote-admin-mcp
cd /mnt/agentic-system/mcp-servers/cluster-execution-mcp
pip install -e .
# For development:
pip install -e ".[dev]"Add to ~/.claude.json:
{
"mcpServers": {
"cluster-execution": {
"command": "/mnt/agentic-system/.venv/bin/python3",
"args": ["-m", "cluster_execution_mcp.server"]
}
}
}All configuration is externalized via environment variables:
Variable | Default | Description |
|
| SSH username for remote execution |
|
| SSH connection timeout (seconds) |
|
| Initial SSH connect timeout (seconds) |
|
| Number of SSH retry attempts |
|
| CPU usage % threshold for offloading |
|
| Load average threshold for offloading |
|
| Memory usage % threshold for offloading |
|
| Command execution timeout (seconds) |
|
| Status check timeout (seconds) |
|
| IP resolution cache TTL (seconds) |
|
| Gateway IP for route detection |
|
| DNS server for IP detection |
|
| Base path for databases |
Node hostnames and IPs can be customized:
Variable | Default | Description |
|
| Mac Pro hostname |
|
| Mac Pro fallback IP |
|
| Mac Studio hostname |
|
| Mac Studio fallback IP |
|
| MacBook Air hostname |
|
| MacBook Air fallback IP |
|
| Inference node hostname |
|
| Inference node fallback IP |
Tool | Description |
| Execute bash commands with automatic cluster routing |
| Get current cluster state and load distribution |
| Explicitly route command to specific node |
| Run multiple commands in parallel across nodes |
# Heavy commands auto-route to least loaded node
result = await cluster_bash("make -j8 all")
# Simple commands run locally
result = await cluster_bash("ls -la")# Force Linux execution
result = await cluster_bash("docker build .", requires_os="linux")
# Force x86_64 architecture
result = await cluster_bash("cargo build", requires_arch="x86_64")# Run on Linux builder
result = await offload_to("podman run -it ubuntu:22.04", node_id="macpro51")
# Run on Mac Studio
result = await offload_to("swift build", node_id="mac-studio")# Run tests across cluster
results = await parallel_execute([
"pytest tests/unit/",
"pytest tests/integration/",
"pytest tests/e2e/"
])# Get cluster health before heavy operations
status = await cluster_status()
# Returns:
# {
# "local_node": "macpro51",
# "nodes": {
# "macpro51": {"cpu_percent": 15.2, "memory_percent": 45.3, ...},
# "mac-studio": {"cpu_percent": 8.1, "memory_percent": 32.1, ...},
# ...
# }
# }Node | OS | Arch | Capabilities | Specialties |
| Linux | x86_64 | docker, podman, raid, nvme, compilation, testing, tpu | compilation, testing, containerization, benchmarking |
| macOS | ARM64 | orchestration, coordination, temporal, mlx-gpu, arduino | orchestration, coordination, monitoring |
| macOS | ARM64 | research, documentation, analysis | research, documentation, mobile |
| macOS | ARM64 | ollama, inference, model-serving, llm-api | ollama-inference, model-serving |
Commands matching these patterns are automatically offloaded:
Build: make, cargo, npm, yarn, pnpm
Test: pytest, jest, mocha, test
Compile: gcc, g++, clang
Container: docker, podman, kubectl
File ops: rsync, scp, tar, zip, find, grep -r
Commands that stay local:
Simple: ls, pwd, cd, echo, cat, head, tail, which, type
All commands use subprocess.run() with list arguments where possible:
# SAFE: List arguments
subprocess.run(["ssh", "-o", "ConnectTimeout=5", f"{user}@{ip}", command])
# Complex shell commands are validated before executionCommands are validated for dangerous patterns:
rm -rf /
rm -rf /*
> /dev/sda
Fork bombs
And more...
StrictHostKeyChecking=accept-new - Accept new hosts but verify returning hosts
BatchMode=yes - Non-interactive mode for scripting
Configurable timeouts and retries
# Install dev dependencies
pip install -e ".[dev]"
# Run tests
pytest tests/ -v
# With coverage
pytest tests/ --cov=cluster_execution_mcp --cov-report=htmlcluster-execution-mcp/
├── src/cluster_execution_mcp/
│ ├── __init__.py # Package exports
│ ├── config.py # Configuration, validation, node definitions
│ ├── router.py # Task routing and IP resolution
│ └── server.py # FastMCP server and tools
├── tests/
│ ├── conftest.py # Pytest fixtures
│ ├── test_config.py # Config module tests (29 tests)
│ ├── test_router.py # Router module tests (21 tests)
│ └── test_server.py # Server and tool tests (21 tests)
└── pyproject.toml # Package configuration# Submit a command
cluster-router submit "make -j8 all"
# Check task status
cluster-router status <task_id>
# Show cluster status
cluster-router cluster-statusCheck cluster health before operations:
User: "Show me cluster status"
Claude Code: cluster_status tool
Output:
macpro51:
CPU: 45.2%
Memory: 18.3%
Load: 3.21
Status: healthy
mac-studio:
CPU: 22.1%
Memory: 54.7%
Load: 2.15
Status: healthy
macbook-air:
CPU: 12.8%
Memory: 38.2%
Load: 1.03
Status: healthyMCP server not loading:
# Check config
cat ~/.claude.json | jq '.mcpServers["cluster-execution"]'
# Test server import
python3 -c "from cluster_execution_mcp.server import main; print('OK')"Node unreachable:
# Test SSH connectivity
ssh marc@macpro51.local hostname
ssh marc@Marcs-Mac-Studio.local hostname
# Check with fallback IP
ssh marc@192.168.1.183 hostnameCommands timing out:
# Increase timeout via environment
export CLUSTER_CMD_TIMEOUT=600 # 10 minutes
export CLUSTER_SSH_TIMEOUT=10 # 10 secondsNew Features:
Proper package structure with pyproject.toml
Environment-based configuration (no hardcoded credentials)
Shared config module with validation functions
Retry logic for SSH connectivity
IP resolution caching with TTL
Inference node support
Security Improvements:
Eliminated shell injection vulnerabilities
Command validation for dangerous patterns
IP validation rejecting loopback/Docker/link-local
SSH host key handling (accept-new)
Code Quality:
Full type hints throughout codebase
Replaced bare except clauses with specific exceptions
Added comprehensive logging
71 unit tests with mocking
Bug Fixes:
Fixed darwin/macos OS alias handling
Proper timeout handling in SSH operations
Better error messages for failed operations
Initial release with basic cluster execution
MIT
Part of the AGI Agentic System
See also:
Node Chat MCP - Inter-node communication
Enhanced Memory MCP - Persistent memory with RAG
Agent Runtime MCP - Goals and task queue
Execute bash command with automatic cluster routing.
Commands are automatically routed to optimal nodes based on:
Current cluster load (CPU, memory, load average)
Command characteristics (build/test/compile patterns)
Node capabilities (OS, architecture)
Heavy commands (make, cargo, pytest, docker, etc.) are automatically offloaded. Simple commands (ls, cat, echo) run locally for speed.
Parameters:
command (required): Bash command to execute
requires_os (optional): Force specific OS (linux/darwin)
requires_arch (optional): Force specific architecture (x86_64/arm64)
auto_route (optional): Enable auto-routing (default: true)
Returns execution result with node info and output.
| Name | Required | Description | Default |
|---|---|---|---|
| command | Yes | ||
| auto_route | No | ||
| requires_os | No | ||
| requires_arch | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full responsibility for transparency. It reveals routing logic (based on cluster load, command characteristics, node capabilities) and states that heavy commands are offloaded while simple ones run locally. It mentions returning execution result with node info and output. It lacks details on failure handling or timeouts, but overall provides solid behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concisely structured with bullet points for routing criteria and parameters. Every sentence adds value, and the information is front-loaded: the first line states the core function. No wasted words.
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?
The description covers routing logic, parameter details, and return value. With an output schema present, it does not need to detail return format. It is complete for a tool with 4 parameters, though it could mention error scenarios or security considerations. Overall, it provides sufficient context for an AI agent to use the tool correctly.
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 0%, so the description must compensate. It explains each parameter: command (required), requires_os/requires_arch (force specific OS/architecture), auto_route (default true). It adds meaning beyond the schema by describing the purpose of requires_os/requires_arch and the auto-routing default. However, it does not enumerate all possible values for requires_os/requires_arch.
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 'Execute bash command with automatic cluster routing', specifying the action (execute), resource (bash command), and core behavior (automatic routing). It distinguishes from siblings like cluster_status (status check) and offload_to (manual offloading) by emphasizing automatic routing.
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 explains when to use the tool: for bash commands with automatic routing. It categorizes commands as 'heavy' (offloaded) or 'simple' (local). It also describes parameters like requires_os and requires_arch for forcing specific nodes. However, it does not explicitly mention when not to use it or compare to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get current cluster status and load distribution.
Shows real-time metrics for all cluster nodes:
CPU usage percentage
Memory usage percentage
1-minute load average
Active task count
Health status (healthy/overloaded)
Reachability
Use this to:
Check cluster health before heavy operations
Determine optimal node for manual routing
Debug cluster connectivity issues
Monitor distributed execution
Returns JSON with status for each node.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility. It discloses real-time nature, listed metrics, and JSON output. It omits details like refresh rate or potential latency, but these are minor for a read-only tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is well-structured with a brief opening, bullet list of metrics, and actionable use cases. Every sentence adds value; no redundancy.
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 parameterless tool with an output schema mentioned, the description covers purpose, metrics, use cases, and return format. It fully informs the agent's decision alongside 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?
No parameters exist, so schema coverage is complete. The description adds no parameter info (none needed). Baseline for 0 parameters is 4, which 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?
Description clearly states it gets cluster status and load distribution with specific metrics. It is distinct from sibling tools like cluster_bash (execution) and offload_to/parallel_execute (task routing), making it easy to select.
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?
Explicit usage scenarios are listed (check health, determine optimal node, debug, monitor). While it doesn't explicitly say when not to use it, the provided contexts are clear and sufficient. Missing exclusions reduces to 4.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Explicitly route command to specific cluster node.
Use when you need to:
Run Linux-specific commands -> offload to macpro51
Test on specific architecture
Balance load manually
Debug node-specific issues
Available nodes:
macpro51: Linux x86_64 builder (docker, podman, compilation)
mac-studio: macOS ARM64 orchestrator
macbook-air: macOS ARM64 researcher
Parameters:
command (required): Bash command to execute
node_id (required): Target node ID
Returns execution result from specified node.
| Name | Required | Description | Default |
|---|---|---|---|
| command | Yes | ||
| node_id | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden, but it only states routing and returns execution result, lacking details on safety, authentication, rate limits, or side effects of command execution.
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?
Structured with bullet points, front-loaded purpose, every sentence adds value, no wasted words.
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?
Covers main aspects: purpose, use cases, nodes, parameters, and return value (execution result); output schema exists. Missing error handling or failure modes.
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 coverage is 0%, description adds meaning by explaining command is a bash command and node_id is target node ID, and lists available nodes, but lacks details on format, constraints, or examples.
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?
Explicitly states routing command to specific cluster node, lists use cases and available nodes, clearly differentiating from sibling tools like cluster_bash, cluster_status, and parallel_execute.
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?
Provides explicit when-to-use scenarios (Linux commands, specific architecture, load balancing, debugging) and lists available nodes, though does not directly compare to siblings or mention when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute multiple commands in parallel across cluster.
Distributes commands across available nodes for maximum parallelism. Use for:
Running test suites across multiple files
Parallel builds
Batch processing
Load testing
Commands are automatically distributed based on node availability and load.
Parameters:
commands (required): List of bash commands to execute in parallel
Returns list of results, one per command, with execution details.
| Name | Required | Description | Default |
|---|---|---|---|
| commands | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries burden. Mentions automatic distribution based on node availability and load, and return format, but lacks details on error handling, timeouts, or resource effects.
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?
Well-structured with bullet points for use cases, but slightly redundant (mentions distribution twice). Generally concise for the content.
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?
Covers purpose, usage, and basic behavior for a simple one-parameter tool, but lacks details on error handling, limits, or output schema specifics.
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 coverage is 0%; description only repeats that commands is a list of bash commands, adding minimal meaning beyond the property name.
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?
Clearly states the action (execute multiple commands in parallel across cluster) and distinguishes from sibling tools like cluster_bash (likely single command) and cluster_status (status).
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?
Provides explicit use cases (test suites, parallel builds, batch processing, load testing) and describes distribution behavior, but does not explicitly state when not to use or suggest alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool has a clearly distinct purpose: cluster_bash for general command execution, cluster_status for monitoring, offload_to for explicit routing to a node, and parallel_execute for batch execution. There is no overlap in functionality.
Tool names follow mixed conventions: cluster_bash and cluster_status share a prefix, but offload_to and parallel_execute use verb phrases without the prefix. The naming patterns are inconsistent, making it harder to infer the pattern at a glance.
With 4 tools, the server is lean but covers the core functions of cluster execution. It could benefit from a dedicated node listing tool, but the count is appropriate for its scope.
The tool set covers the key operations: executing commands, getting status, explicit routing, and parallel execution. Minor gaps like the absence of a tool to list available nodes dynamically are present but do not severely hinder typical workflows.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Operate Linux, macOS and Windows from your LLM. Every action runs through an auditable allowlist.
On-demand GPU nodes for agents: create nodes, run commands, and submit jobs, billed by the minute.
Intent execution engine for autonomous agent task routing
AI work orchestration for plans, tasks, teams, and coding-agent dispatch.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/marc-shade/cluster-execution-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
