--- name: execbox.xyz description: ExecBox provides remote sandboxed code execution across multiple programming languages, returning structured JSON output including stdout, stderr, exit code, timing, and memory usage. It offers two execution tiers differentiated by CPU timeout (15s vs 30s) and RAM allocation (512MB vs 1GB). Network access is disabled in all sandboxes. host: execbox.xyz --- # execbox.xyz ExecBox is a remote code execution host targeting agents that need to compile and run untrusted or dynamically generated code in an isolated environment. It serves use cases such as running algorithm outputs, evaluating code snippets, or benchmarking numeric workloads. It is distinguished by two resource tiers rather than a single endpoint, allowing cost-appropriate selection based on workload intensity. ## When to use this host Use ExecBox when an agent needs to execute source code remotely in a sandboxed environment and requires structured output (stdout, stderr, exit code, timing, memory). Choose execute-code-compute-tier for lightweight scripts and quick computations; choose execute-heavy-code for recursive algorithms, benchmarks, or memory-intensive workloads. Do not use ExecBox for any code that requires network access — sockets and HTTP requests are blocked in all tiers. Do not use it for long-running jobs exceeding 30 seconds or workloads requiring more than 1GB RAM; for those, a full cloud compute service (e.g. AWS Lambda with custom limits, Google Cloud Run, or a dedicated VM) would be more appropriate. ExecBox does not provide persistent storage, scheduling, or stateful execution between calls. ## Capabilities ### Sandboxed Code Execution Remotely compiles and runs source code in an isolated environment, returning structured output including stdout, stderr, exit code, wall-clock time, and memory usage. Two tiers are available: a standard tier (15s CPU, 512MB RAM) and a heavy tier (30s CPU, 1GB RAM). - **`execute-code-compute-tier`** — Executes submitted source code in a sandboxed environment with a 15-second CPU timeout and 512MB RAM, returning stdout, stderr, exit code, timing, and memory usage as JSON. - **`execute-heavy-code`** — Runs source code in a remote sandbox with a 30-second CPU timeout and 1 GB RAM, returning stdout, stderr, exit code, wall-clock time, and memory usage. ## Workflows ### Tiered Execution with Fallback *Use when an agent needs to run code but is uncertain whether it will complete within the standard resource limits — attempt the cheaper tier first and escalate if it times out or exceeds memory.* 1. **`execute-code-compute-tier`** — Attempt execution on the standard tier (15s CPU, 512MB RAM) to minimize cost for typical workloads. 2. **`execute-heavy-code`** — If the standard tier returns a timeout exit code or memory error, re-submit the same code to the heavy tier (30s CPU, 1GB RAM) to obtain a successful result. ## Skill reference ### `execute-code-compute-tier` **ExecBox Compute Code Execution** — Executes submitted source code in a sandboxed environment with a 15-second CPU timeout and 512MB RAM, returning stdout, stderr, exit code, timing, and memory usage as JSON. *Use when:* Use when an agent needs to remotely compile and run code in a supported language (e.g. Python, JavaScript, C, Java) with optional stdin, compiler flags, or command-line arguments, and requires structured output of the execution result. *Not for:* Do not use for code that requires network access (sockets or HTTP requests are disabled). Not suitable for long-running jobs exceeding 15 seconds CPU time or workloads requiring more than 512MB RAM. **Inputs:** - `language_id` (number, required) — Judge0 language ID identifying the language/runtime. GET /languages for valid IDs. Examples: 71=Python 3, 63=JavaScript, 50=C (GCC), 62=Java. - `source_code` (string, required) — Source code to execute, up to 100,000 characters. Network access is disabled; code that opens sockets or makes HTTP requests will fail. - `stdin` (string) — Standard input text passed to the running program. - `compiler_options` (string) — Compiler flags passed to the compiler (e.g. "-O2 -Wall"). Must start with "-". Omit if not needed. Do not put natural language here. - `command_line_arguments` (string) — Arguments passed to the compiled binary at runtime (e.g. "7" or "--input file.txt"). Omit for most use cases. Do not put natural language here. **Returns:** Returns stdout, stderr (null if none), exit_code, execution time in seconds, peak memory in KB, language object (id + name), and status object (id + description such as "Accepted"). **Example:** `{"language_id": 50, "source_code": "#include \n#include \nint main(int argc, char **argv) { printf(\"n=%d\\n\", argc >= 2 ? atoi(argv[1]) : 0); return 0; }", "stdin": "hello\n", "compiler_options": "-O2 -Wall", "command_line_arguments": "7"}` --- ### `execute-heavy-code` **ExecBox Heavy Execute** — Runs source code in a remote sandbox with a 30-second CPU timeout and 1 GB RAM, returning stdout, stderr, exit code, wall-clock time, and memory usage. *Use when:* Use when an agent needs to compile and run computationally intensive code (e.g. recursive algorithms, benchmarks, heavy numeric workloads) in an isolated environment and retrieve the program output, timing, and memory stats. *Not for:* Do not use for code that requires network access — sockets and HTTP requests are disabled in the sandbox. For lightweight or quick scripts, consider a lower-tier execution endpoint to avoid unnecessary cost. **Inputs:** - `language_id` (number, required) — Judge0 language ID identifying the runtime. GET /languages for valid IDs. Examples: 71=Python 3, 63=JavaScript, 50=C (GCC 9.2.0), 62=Java. - `source_code` (string, required) — Source code to execute, up to 100,000 characters. Network access is disabled; code opening sockets or making HTTP requests will fail. - `stdin` (string) — Standard input passed to the running program. Omit or leave empty if the program reads no stdin. - `compiler_options` (string) — Compiler flags passed to the compiler (e.g. "-O2 -Wall"). Must start with "-". Omit if unsure. Do not put natural language here. - `command_line_arguments` (string) — Arguments passed to the compiled binary at runtime (e.g. "--input file.txt"). Omit for most use cases. Do not put natural language here. **Returns:** Returns stdout with program output, wall-clock time string (e.g. "2.797"), memory in KB (e.g. 27360), language object, and status object with id=3 (Accepted) on success. **Example:** `{"language_id": 50, "source_code": "#include \n#include \nstatic inline long long fib_recursive(int n){ if(n<=1) return n; return fib_recursive(n-1)+fib_recursive(n-2); }\nint main(){ clock_t s=clock(); long long r=fib_recursive(44); double e=(double)(clock()-s)/CLOCKS_PER_SEC; printf(\"fib(44)=%lld\\nelapsed_sec=%.6f\\n\",r,e); return 0; }", "stdin": "", "compiler_options": "-O0 -Wall -Wextra -pedantic", "command_line_arguments": ""}` ---