This server presents a single tool with critical deficiencies across naming, description, schema documentation, and error handling. The tool name 'execute_skill_action' is generic and violates verb_noun conventions. While an input schema is technically present in the specification, the actual server code (mcp_server.py) does not register any tools or validate inputs, it only prints a static JSON response. The tool description lacks clarity on when/why to use it, what it returns, and failure modes. Parameter descriptions exist but are minimal. The server provides no error handling, no output schema documentation, no audit trail, and no security controls. This is a proof-of-concept stub that does not implement the MCP protocol correctly.
Tools (1)
execute_skill_actionwritesource verified32/100
Execute arbitrary code in an isolated ephemeral microVM with support for multiple runtime languages and configurable timeout
Tool name 'execute_skill_action' is generic and violates verb_noun convention. Does not start with a clear action verb. Should be 'execute_code' or 'run_code' to reflect the actual intent.
Server code does not actually register tools or implement MCP protocol. mcp_server.py only prints a static JSON response and does not process tool calls or accept input from stdin.
No output schema documented. LLMs cannot know what fields to expect from execute_skill_action. Specification hints at returning sandbox_execution_id, exit_code, stdout_captured, but this is not formally declared in a response schema.
No error handling or recovery guidance. What happens if the script times out, the language runtime fails, or the microVM crashes? LLM has no guidance on retrying or alternative actions.
execute_skill_action
Recommendations
Rename 'execute_skill_action' to 'execute_code' or 'run_code_in_sandbox' to clearly convey the action and resource.
Rewrite tool description to explicitly state: (1) What it does: 'Executes user-provided code in an isolated, ephemeral microVM'; (2) When to use: 'Use this to run scripts, computations, or analysis on user data without modifying persistent infrastructure'; (3) What it returns: 'Execution result with stdout, exit code, memory usage, and boot latency'; (4) Prerequisites and safety: 'Code is isolated and does not persist; long-running code will timeout'.
Add an explicit output schema documenting all fields: sandbox_execution_id (string), runtime_language (string), exit_code (integer), stdout_captured (string), stderr_captured (string, if applicable), microvm_boot_latency_ms (integer), memory_used_mb (float), execution_duration_ms (integer), filesystem_diff_persisted (boolean).
Add 'language' as a constrained enum: ['PYTHON_3_13', 'PYTHON_3_12', 'NODE_18', 'BASH_5']. Remove the default to force explicit selection, or document that the default is safe for all invocations.
Constrain 'timeout_ms' to a range: minimum 1000 (1 second), maximum 300000 (5 minutes). Add constraint documentation: 'Timeout must be between 1,000 and 300,000 ms. Requests exceeding this will be rejected with a 'timeout_out_of_range' error.'
Improve 'script_code' parameter description to include safety guidelines: 'Source code to execute. No external network requests allowed. Forbidden modules: os.system, subprocess, socket. Code exceeding 100KB will be rejected.'
Tool description does not explain WHEN to use this tool, what PREREQUISITES exist, or what SIDE EFFECTS occur. 'Execute arbitrary code' is too vague and lacks the 10-word minimum depth for LLM selection.
No input validation, security controls, or permission gates. Tool accepts 'arbitrary code' with no sanitization. Agents could pass shell injection payloads, malicious scripts, or commands requesting secrets without restriction.
'language' parameter default 'PYTHON_3_13' is reasonable, but enum of allowed runtimes is not declared. LLM could hallucinate invalid values like 'NODEJS_18' or 'RUST_1.70' without knowing what's actually supported.
Parameter descriptions are minimal. 'Source code to execute in the specified runtime' does not explain language constraints, file size limits, or forbidden libraries. LLMs cannot infer safe usage.
'timeout_ms' parameter has no documented constraints. Is 5000ms a hard limit, a default, or a suggestion? Can LLM pass 1000000 (16+ minutes) and block indefinitely? Min/max bounds are missing.
No audit trail, no logging, no traceability. If an agent executes malicious code or crashes a microVM, there is no way to trace who/what/when. Violates compliance and incident response requirements.
execute_skill_action
Implement actual tool registration in mcp_server.py. The current code only prints a static response and does not handle stdin-based tool calls. Implement a proper request/response loop that parses incoming MCP tool call messages, validates inputs, invokes client.execute_in_isolated_microvm(), and returns structured responses.
Add error classification to tool response. Return distinct error codes for timeout (execution_timeout), invalid_language (unsupported_runtime), code_too_large (input_exceeds_limit), and internal errors (sandbox_unavailable). Each error should include actionable recovery guidance.
Gate tool execution behind permission checks or scope validation. Require agents to declare 'exec:code' scope before calling. Log all executions with timestamp, agent ID, script hash, language, and result.
Add dry-run or confirmation step for irreversible operations. Consider requiring agents to first call 'analyze_code_safety' or returning an 'execution_confirmation_required' result so users can review before actual execution.
Implement input sanitization to prevent prompt injection. Scan script_code for suspicious patterns (hardcoded credentials, shell metacharacters, external API calls) and reject or warn before execution.