_ registry / mcp streamable-http · checked 11h ago

sandbox-mcp

https://mcp.sandboxes.as-south-1.ai.neevcloud.com

Registry code: 2132936f8c5a6c12

api record

A NeevCloud sandbox as native tools: run commands, edit files, manage processes, snapshots. Endpoint shown with the default value for region; other values are listed by the publisher.

from a public catalogue that lists it, not from the operator

endpoint
https://mcp.sandboxes.as-south-1.ai.neevcloud.com/mcp
protocol
streamable-http ·2025-06-18
authentication
none observed
public key
none — nobody has proven they own this listing · is it yours? claim it
karma
0 · newcomer
_ is it live, free and safe measured by this hub
Is sandbox-mcp live?
Yes — it answered the hub's last check (checked 11h ago). It answered 100% of checks over the last 30 days.
Is sandbox-mcp free to use?
Not anonymously — it asks for a key or a login before it will serve. Whether that key costs anything is the operator's plan to say: the hub measured the door, not the pricing.
What tools does sandbox-mcp have?
30 tools: fs_read, process_get, process_list, interpreter_run, process_start, fs_list, fs_write, expose_port, ….
Is sandbox-mcp safe to connect?
The hub found no text in its card or tool descriptions aimed at the agent reading them. It measures what the server answers, not its code — grant it only the access its tools need.
reachable
live
uptime, 30 days
100%

90 days 100%· all time 100%

latency
744ms

last good check

priced tools
0

of 30 tools

_ answered our checks, 90 days 2 checks · signed record
  • unknown → live
_ usage and payments 30 days

Calls placed through this hub's router, from its own receipts. Every caller and every payer counts the same; the chain total is counted from three payers.

accounts
0

through this hub

calls served
0

successful

paid through this hub
0 USDC

what callers paid

_ what it can do 30 tools
30 auth-required 30 of 30 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • fs_read auth-required never probed

    Read a file from the sandbox workspace. Reach for this to inspect a file the sandbox already holds, including one an earlier call wrote. A path may be relative to the workspace root or absolute, and an absolute one means the workspace as the sandbox sees it; either way a path that leaves the workspace is rejected. The read is size-capped by the sandbox: to read a file larger than that, set length to take one slice at a time and offset to start where the last slice ended, and stop when eof comes back true. Set encoding to base64 to read a file that is not text.

    mcp-tool

    {
      "type": "object",
      "required": [
        "path"
      ],
      "properties": {
        "cwd": {
          "type": "string",
          "description": "Working-directory base that a relative path is resolved against, itself relative to the workspace root or absolute inside it."
        },
        "path": {
          "type": "string",
          "description": "File path, relative to the workspace root or to cwd when that is set, or absolute inside the workspace."
        },
        "length": {
          "type": "integer",
          "description": "How many bytes to return; omit to read to the end of the file."
        },
        "offset": {
          "type": "integer",
          "description": "Byte to start reading at; omit or 0 to read from the beginning."
        },
        "encoding": {
          "type": "string",
          "description": "How to render the content: \"utf8\" (default) or \"base64\" for a file that is not text."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 35 lines
  • process_get auth-required never probed

    Return a started process's current state and, once it has exited, its exit code. Reach for this to find out whether a process from process_start is still running. Set wait to block until it exits instead of polling; that wait is bounded by the sandbox's ceiling and returns the still-running snapshot if the process outlasts it. An exited process stays queryable only for the sandbox's retention window, after which its process_id is not_found.

    mcp-tool

    {
      "type": "object",
      "required": [
        "process_id"
      ],
      "properties": {
        "wait": {
          "type": "boolean",
          "description": "When true, block until the process exits, bounded by the sandbox's wait ceiling."
        },
        "process_id": {
          "type": "string",
          "description": "Identifier returned by process_start."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 23 lines
  • process_list auth-required never probed

    Snapshot every process the sandbox is tracking, with each one's program, arguments, working directory, state and exit code. Reach for this to find out what is running when the process_id from an earlier process_start is not at hand. Processes exited longer ago than the sandbox's retention window are already gone from the list.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 12 lines
  • interpreter_run auth-required never probed

    Run Python in a persistent kernel inside the sandbox and return its output. Variables, imports and loaded data persist between calls in the same context, so build on earlier cells instead of re-running them. A cell that raises is not a call error: the exception is in error and end_reason is "error". A cell gets about forty-five seconds; one that runs longer is interrupted with end_reason "deadline_exceeded", so run long jobs with process_start instead. end_reason "kernel_restarted" or "memory_exceeded" means the context's state was lost. Output beyond the size cap is dropped and truncated is true.

    mcp-tool

    {
      "type": "object",
      "required": [
        "code"
      ],
      "properties": {
        "code": {
          "type": "string",
          "description": "Python source of the cell."
        },
        "context_id": {
          "type": "string",
          "description": "Kernel context to run in; omit to use the sandbox's default context."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 23 lines
  • process_start auth-required never probed

    Start a program in the sandbox and return immediately with its process_id. Reach for this for anything long-running — a dev server, a watcher, a build that outlasts one request — where exec would hit its per-call time ceiling. The process outlives the call that started it and keeps running in the sandbox until it exits, is killed, or reaches the sandbox's maximum process lifetime, at which point its process group is SIGKILLed and it is recorded as exit code 137. The sandbox caps how many processes run at once, and a start beyond that cap fails with resource_exhausted rather than queueing. Follow up with process_get for its state and exit code, process_logs for its output, and process_kill to stop it.

    mcp-tool

    {
      "type": "object",
      "required": [
        "program"
      ],
      "properties": {
        "cwd": {
          "type": "string",
          "description": "Working directory, relative to the workspace root or absolute inside it; defaults to the root."
        },
        "env": {
          "type": [
            "null",
            "array"
          ],
          "items": {
            "type": "string"
          },
          "description": "Environment additions in KEY=VALUE form, appended to the inherited environment."
        },
        "args": {
          "type": [
            "null",
            "array"
          ],
          "items": {
            "type": "string"
          },
          "description": "Argument vector passed to the program, excluding the program itself."
        },
        "stdin": {
          "type": "string",
          "description": "Content written to the process's standard input, which is then closed."
        },
        "program": {
          "type": "string",
          "description": "Path or name of the binary to execute; resolved against PATH when not a path."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        },
        "max_lifetime_ms": {
          "type": "integer",
          "description": "Wall-clock ceiling for this process in milliseconds; omit or 0 for the server default (one hour unless configured otherwise). Larger values are clamped to the server ceiling. On expiry the process is killed and reports exit code 137."
        }
      },
      "additionalProperties": false
    }
    arguments 51 lines
  • fs_list auth-required 38h ago

    List the entries of a directory in the sandbox workspace, each with its type, size, permissions and modification time. Reach for this to find out what the sandbox actually holds before reading or running anything. A path may be relative to the workspace root or absolute; omit path to list the root itself. Set recursive to walk the whole subtree, and max_count to bound the result — an unbounded recursive walk of a large tree returns a large one.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "cwd": {
          "type": "string",
          "description": "Working-directory base that a relative path is resolved against, itself relative to the workspace root or absolute inside it."
        },
        "path": {
          "type": "string",
          "description": "Directory path, relative to the workspace root or to cwd when that is set, or absolute inside the workspace; omit to list the root."
        },
        "max_count": {
          "type": "integer",
          "description": "Maximum number of entries to return; omit or 0 for no cap."
        },
        "recursive": {
          "type": "boolean",
          "description": "When true, walk the whole subtree under path instead of one level."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 28 lines
  • fs_write auth-required never probed

    Write content to a file in the sandbox workspace, creating it or replacing it whole. Reach for this to place a script, config, dataset or source file the sandbox will use. A path may be relative to the workspace root or absolute, and one that leaves the workspace is rejected. A write with no offset is atomic and size-capped, and the file persists in the sandbox after the call returns, so a later exec, process_start or fs_read in the same sandbox sees it. To write a file larger than one call takes, send the first part with no offset and each later part with offset set to the bytes_written the previous call returned; if the offset does not match, the error gives the size to continue from. If the sandbox can obtain the file itself, though — downloading it, or copying it from elsewhere on disk — run that with exec instead: it is far quicker than sending the bytes here a part at a time, and they never have to pass through you. Set encoding to base64 to write content that is not text.

    mcp-tool

    {
      "type": "object",
      "required": [
        "path",
        "content"
      ],
      "properties": {
        "cwd": {
          "type": "string",
          "description": "Working-directory base that a relative path is resolved against, itself relative to the workspace root or absolute inside it."
        },
        "path": {
          "type": "string",
          "description": "File path, relative to the workspace root or to cwd when that is set, or absolute inside the workspace."
        },
        "offset": {
          "type": [
            "null",
            "integer"
          ],
          "description": "Byte to append at, which must equal the file's current size. Omit to replace the whole file."
        },
        "content": {
          "type": "string",
          "description": "Content to write, as UTF-8 text or base64 per the encoding field."
        },
        "encoding": {
          "type": "string",
          "description": "How to read the content field: \"utf8\" (default) or \"base64\" for bytes that are not text."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 39 lines
  • expose_port auth-required never probed

    Publish a preview URL for a port your server inside the sandbox is already listening on. It exposes the port, it does not start anything, so start your server first. The URL it returns needs no credential -- anyone who has it can reach the port -- so treat it as a secret and do not post it publicly. Exposing a port that is already exposed returns the same URL and changes nothing else. Some ports are reserved by the platform and will be refused. Withdraw the URL with revoke_port once you no longer need the preview.

    mcp-tool

    {
      "type": "object",
      "required": [
        "port"
      ],
      "properties": {
        "port": {
          "type": "integer",
          "maximum": 65535,
          "minimum": 1,
          "description": "The port a server inside the sandbox is listening on. Some ports are reserved by the platform and are refused."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 21 lines
  • revoke_port auth-required never probed

    Stop serving a port through its preview URL, so the URL no longer works. Do this once you no longer need the preview: the URL needs no credential, so anyone still holding it can reach the port until you revoke it. Revoking a port that is not exposed succeeds and changes nothing. Exposing the same port again afterwards gives you a different URL, never the revoked one.

    mcp-tool

    {
      "type": "object",
      "required": [
        "port"
      ],
      "properties": {
        "port": {
          "type": "integer",
          "maximum": 65535,
          "minimum": 1,
          "description": "The exposed port to stop serving through its preview URL."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 21 lines
  • rollback_sandbox auth-required never probed

    Return your sandbox to a snapshot you took earlier. Everything written since that snapshot is discarded and cannot be recovered -- files, installed packages and running processes alike -- so take a fresh snapshot first if the current state is worth keeping. Use an id from list_snapshots, and only one whose state says it has finished: an id from anywhere else may belong to a different sandbox, and rolling onto it would replace your sandbox's contents with that one's. The processes that were running when the snapshot was taken come back from that moment; anything started after it is gone.

    mcp-tool

    {
      "type": "object",
      "required": [
        "snapshot_id"
      ],
      "properties": {
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        },
        "snapshot_id": {
          "type": "string",
          "format": "uuid",
          "description": "The id of a finished snapshot of this sandbox, as list_snapshots reports it. Do not pass an id from anywhere else."
        }
      },
      "additionalProperties": false
    }
    arguments 20 lines
  • exec auth-required never probed

    Run a program in the sandbox and wait for it to finish, returning its buffered stdout, stderr and exit code. Reach for this for one-shot commands — a build, a test run, a package install. The sandbox persists between calls: files written and processes left running by earlier calls are still there, and this call sees them. A non-zero exit is reported in exit_code and is not an error. The call is bounded by the sandbox's configured per-call time ceiling, and a program that outlives it is killed along with its whole process group; that call fails with deadline_exceeded and the output buffered so far is discarded, so start anything that never exits on its own — docker compose up, a dev server, a file watcher — or may outlast the ceiling with process_start instead. Each of stdout and stderr is capped, and truncated=true means output was dropped.

    mcp-tool

    {
      "type": "object",
      "required": [
        "program"
      ],
      "properties": {
        "cwd": {
          "type": "string",
          "description": "Working directory, relative to the workspace root or absolute inside it; defaults to the root."
        },
        "env": {
          "type": [
            "null",
            "array"
          ],
          "items": {
            "type": "string"
          },
          "description": "Environment additions in KEY=VALUE form, appended to the inherited environment."
        },
        "args": {
          "type": [
            "null",
            "array"
          ],
          "items": {
            "type": "string"
          },
          "description": "Argument vector passed to the program, excluding the program itself."
        },
        "program": {
          "type": "string",
          "description": "Path or name of the binary to execute; resolved against PATH when not a path."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 43 lines
  • fs_stat auth-required never probed

    Return one entry's type, size, permissions, modification time and symlink target. Reach for this when only the metadata matters, so a large file need not be read. A path that does not exist is an error; use fs_exists to test for one without failing.

    mcp-tool

    {
      "type": "object",
      "required": [
        "path"
      ],
      "properties": {
        "cwd": {
          "type": "string",
          "description": "Working-directory base that a relative path is resolved against, itself relative to the workspace root or absolute inside it."
        },
        "path": {
          "type": "string",
          "description": "Path of the entry to inspect, relative to the workspace root or to cwd when that is set, or absolute inside the workspace."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 23 lines
  • fs_exists auth-required never probed

    Report whether a path exists in the sandbox workspace, with its metadata when it does. Reach for this to branch on a file's presence: a missing path is a successful result with exists=false, not an error.

    mcp-tool

    {
      "type": "object",
      "required": [
        "path"
      ],
      "properties": {
        "cwd": {
          "type": "string",
          "description": "Working-directory base that a relative path is resolved against, itself relative to the workspace root or absolute inside it."
        },
        "path": {
          "type": "string",
          "description": "Path of the entry to inspect, relative to the workspace root or to cwd when that is set, or absolute inside the workspace."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 23 lines
  • fs_remove auth-required never probed

    Delete a file or directory from the sandbox workspace. Reach for this to clean up what an earlier call created. A non-empty directory is rejected unless recursive is set, and the deletion cannot be undone.

    mcp-tool

    {
      "type": "object",
      "required": [
        "path"
      ],
      "properties": {
        "cwd": {
          "type": "string",
          "description": "Working-directory base that a relative path is resolved against, itself relative to the workspace root or absolute inside it."
        },
        "path": {
          "type": "string",
          "description": "Entry to delete, relative to the workspace root or to cwd when that is set, or absolute inside the workspace."
        },
        "recursive": {
          "type": "boolean",
          "description": "When true, delete a non-empty directory and everything under it."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 27 lines
  • fs_move auth-required never probed

    Rename or move an entry within the sandbox workspace, creating the destination's parents as needed. Reach for this to relocate a file without reading and rewriting it. Both endpoints may be relative to the workspace root or absolute, and neither may be the root itself. An existing file at the destination is overwritten, but an existing directory there is refused rather than replaced.

    mcp-tool

    {
      "type": "object",
      "required": [
        "source",
        "destination"
      ],
      "properties": {
        "cwd": {
          "type": "string",
          "description": "Working-directory base applied to both endpoints, itself relative to the workspace root or absolute inside it."
        },
        "source": {
          "type": "string",
          "description": "Existing entry to move, relative to the workspace root or to cwd when that is set, or absolute inside the workspace."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        },
        "destination": {
          "type": "string",
          "description": "New path for the entry, relative to the workspace root or to cwd when that is set, or absolute inside the workspace."
        }
      },
      "additionalProperties": false
    }
    arguments 28 lines
  • process_logs auth-required never probed

    Read a process's captured stdout and stderr from a byte cursor, returning the new entries, the cursor to resume from, and the process's current state. Reach for this to follow what a process from process_start is doing. Output is held in a fixed-size ring buffer, so dropped=true means output was overwritten before it was read; poll often enough to keep up. This tool cannot stream: it returns what is buffered at call time.

    mcp-tool

    {
      "type": "object",
      "required": [
        "process_id"
      ],
      "properties": {
        "cursor": {
          "type": "integer",
          "description": "Byte offset on the combined stream to read from, as returned by a previous call; omit or 0 for the oldest retained byte."
        },
        "process_id": {
          "type": "string",
          "description": "Identifier returned by process_start."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 23 lines
  • process_kill auth-required never probed

    Send a signal to a process started by process_start; the signal defaults to SIGTERM and only SIGHUP, SIGINT, SIGQUIT, SIGKILL and SIGTERM are accepted. Reach for this to stop a long-running process you started. The signal goes to the whole process group, so descendants get it too, and signalled=true means it was delivered, not that the process has exited — confirm with process_get. Signalling an already-exited process is a success with signalled=false.

    mcp-tool

    {
      "type": "object",
      "required": [
        "process_id"
      ],
      "properties": {
        "signal": {
          "enum": [
            0,
            1,
            2,
            3,
            9,
            15
          ],
          "type": "integer",
          "description": "Signal number to deliver: 1, 2, 3, 9 or 15; omit or 0 for SIGTERM."
        },
        "process_id": {
          "type": "string",
          "description": "Identifier returned by process_start."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 31 lines
  • create_sandbox auth-required never probed

    Create a sandbox and wait until it is reachable. Returns its id: pass it as sandbox_id on later calls for this sandbox. For work beyond general coding, pick a template with list_sandbox_templates first. Reuse a sandbox you already have (list_sandboxes) instead of creating another for the same work. If the next call says it is not ready, wait and retry rather than creating another. A sandbox costs quota until deleted, so call delete_sandbox when done.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "name": {
          "type": "string",
          "pattern": "^[a-z]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "minLength": 1,
          "description": "Optional. Lowercase letters, digits and hyphens. Omit it: your first sandbox takes the name you are configured with, later ones get a generated name."
        },
        "labels": {
          "type": "object",
          "description": "Optional. Key-value tags to find this sandbox with list_sandboxes, e.g. {\"task\": \"build-api\"}. Up to 16; keys and values up to 63 characters.",
          "maxProperties": 16,
          "additionalProperties": {
            "type": "string",
            "maxLength": 63
          }
        },
        "sandbox_template_id": {
          "type": "string",
          "pattern": "^sb-[a-zA-Z0-9-]+$",
          "minLength": 1,
          "description": "Optional. Template id from list_sandbox_templates. Omit for general coding."
        },
        "idle_timeout_seconds": {
          "type": "integer",
          "minimum": 0,
          "description": "How long the sandbox may sit idle before it is paused, in seconds. Any tool call counts as activity. Omit to use the account default, or send 0 for no idle limit -- which means it keeps costing quota until you delete it."
        }
      },
      "additionalProperties": false
    }
    arguments 33 lines
  • list_sandboxes auth-required 11h ago

    List sandboxes in this project with their id, phase, template and labels. Use it to find a sandbox to reuse, filtering by the labels you set at create. Paged: fetch the next page while total is above what you have seen.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "name": {
          "type": "string",
          "maxLength": 63,
          "description": "Optional. Only sandboxes whose name contains this, ignoring case."
        },
        "page": {
          "type": "integer",
          "minimum": 1,
          "description": "Page to read, from 1. Omit for the first page."
        },
        "label": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 127
          },
          "maxItems": 16,
          "description": "Optional. Only sandboxes carrying all of these labels, each as key=value, e.g. [\"task=build-api\"]."
        },
        "limit": {
          "type": "integer",
          "maximum": 100,
          "minimum": 1,
          "description": "Sandboxes per page, up to 100. Omit for 20."
        },
        "status": {
          "enum": [
            "Pending",
            "Ready",
            "NotReady",
            "Unknown",
            "Pausing",
            "Paused",
            "RestoreFailed"
          ],
          "type": "string",
          "description": "Optional. Only sandboxes in this phase."
        }
      },
      "additionalProperties": false
    }
    arguments 44 lines
  • list_sandbox_templates auth-required 11h ago

    List templates create_sandbox can use. Each description says what the template is for: pick by the work, since a sandbox keeps its template for life. interpreter_run works only on a template whose interpreter field is true. Omit sandbox_template_id for the general dev template. Prefer active over deprecated.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "page": {
          "type": "integer",
          "minimum": 1,
          "description": "Page to read, from 1. Omit for the first page."
        },
        "limit": {
          "type": "integer",
          "maximum": 100,
          "minimum": 1,
          "description": "Templates per page, up to 100. Omit for 20."
        }
      },
      "additionalProperties": false
    }
    arguments 17 lines
  • get_sandbox auth-required 38h ago

    Report the state of your sandbox. Use it after create_sandbox, or when a call says the sandbox is not ready. The phase it returns means: "Ready" you can run commands now; "Paused" also fine, the next call wakes it, so do not create another; "Pending", "NotReady" or "Unknown" it is still starting, so wait a few seconds and check again; "RestoreFailed" the sandbox is broken and will not recover, so delete it and create a new one.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 12 lines
  • delete_sandbox auth-required never probed

    Delete your sandbox and everything stored in it. Do this when the work is done: a sandbox costs quota for as long as it exists, and nothing else removes it. The files and processes in it are gone and cannot be recovered.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 12 lines
  • pause_sandbox auth-required never probed

    Stop your sandbox without deleting it, so you stop paying for run time while its state is kept. Files on disk, memory and running processes are saved and come back when it resumes, so there is nothing to restart. Use this when the work is paused rather than finished: resume_sandbox brings it back, and any other tool call wakes it too. A paused sandbox still costs storage, and one left paused long enough is deleted, so use delete_sandbox when the work is actually done.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 12 lines
  • resume_sandbox auth-required never probed

    Start your paused sandbox again, which resumes paying for run time. It returns before it is ready, so if the next call says it is not ready, wait a moment and check with get_sandbox rather than creating another sandbox. Your files and the processes that were running before the pause come back as they were, so check with process_get before starting one again. Resuming a sandbox that is already running changes nothing.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 12 lines
  • keepalive_sandbox auth-required never probed

    Reset your sandbox's idle timer, so it is not paused or deleted for sitting idle. Every other tool call already resets it, so you only need this while work runs somewhere else and nothing here touches the sandbox. Each call keeps it alive -- and therefore costing quota -- for another idle window, so do not call it in a loop on a sandbox nobody is using.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 12 lines
  • update_sandbox_timeout auth-required never probed

    Change how long your sandbox survives, which decides how much it costs. Fields you leave out stay as they are. Sending 0 turns that limit off completely, so the sandbox is never reclaimed for it and keeps costing quota until something deletes it -- prefer a real number. When the idle window runs out the sandbox is paused, not deleted, so your files are kept and the work can be resumed.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        },
        "idle_timeout_seconds": {
          "type": "integer",
          "minimum": 0,
          "description": "Seconds without activity before the sandbox is paused. Any tool call counts as activity. Omit to leave it unchanged, or send 0 so it never idles out, which keeps it costing quota until something deletes it."
        },
        "max_lifetime_seconds": {
          "type": "integer",
          "minimum": 0,
          "description": "Seconds after creation before the sandbox is paused regardless of activity. Omit to leave it unchanged, or send 0 for no lifetime limit."
        },
        "paused_retention_seconds": {
          "type": "integer",
          "minimum": 0,
          "description": "Seconds a paused sandbox is kept before it is deleted with everything in it. Omit to leave it unchanged, or send 0 to keep it paused for as long as it costs stored data."
        }
      },
      "additionalProperties": false
    }
    arguments 27 lines
  • list_ports auth-required never probed

    List the ports on your sandbox that are currently reachable through a preview URL, each with its URL. Returns an empty list when no port is exposed. Anyone holding one of these URLs can reach that port without signing in, so treat every URL it returns as a secret.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 12 lines
  • create_snapshot auth-required never probed

    Save your sandbox's current state, so rollback_sandbox can return to it later. It returns as soon as the request is accepted, which is before the snapshot is usable: check list_snapshots for its state rather than rolling back immediately. Take one before anything you might want to undo. Each snapshot stores a copy of your sandbox's disk and costs quota of its own for as long as the sandbox exists, so do not take one per step. Deleting the sandbox deletes its snapshots with it: none of them outlives the sandbox.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "name": {
          "type": "string",
          "pattern": "^[a-z]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Label for this snapshot, lowercase letters, digits and hyphens, starting with a letter. Omit to leave it unnamed; a name makes it easier to pick the right one out of list_snapshots later."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        },
        "snapshot_type": {
          "enum": [
            "full",
            "filesystem"
          ],
          "type": "string",
          "description": "Optional. Type of snapshot to capture. Set to \"filesystem\" to capture only the disk (faster, but memory is lost). Set to \"full\" or omit to capture both disk and memory."
        }
      },
      "additionalProperties": false
    }
    arguments 26 lines
  • list_snapshots auth-required 11h ago

    List the snapshots taken from your sandbox, each with the id rollback_sandbox needs. Use it to confirm a snapshot has finished before rolling back to it, and to see how many are still costing quota. The answer comes one page at a time and carries the total number of snapshots alongside it, so if that total is higher than the number you have seen, ask for the next page. An empty list means you have taken none, which is not the same as having reached the end of the pages.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "page": {
          "type": "integer",
          "minimum": 1,
          "description": "Which page of results to read, counting from 1. Omit for the first page."
        },
        "limit": {
          "type": "integer",
          "maximum": 100,
          "minimum": 1,
          "description": "How many snapshots to return per page, up to 100. Omit for the default of 20."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 23 lines
  • get_sandbox_metrics auth-required 38h ago

    Read CPU, memory and disk use for your sandbox over a time window, as a series of samples. Use it to tell a slow command apart from one that has run the sandbox out of memory or disk -- a process killed for no visible reason usually shows up here. With no window given it reads the last hour.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "to": {
          "type": "string",
          "format": "date-time",
          "description": "End of the window (RFC3339). Defaults to now, or for a paused sandbox with `from` also unset, to when it paused."
        },
        "from": {
          "type": "string",
          "format": "date-time",
          "description": "Start of the window (RFC3339). Defaults to one hour before `to`."
        },
        "step": {
          "type": "string",
          "description": "Resolution (e.g. \"60s\", \"5m\"). Server clamps to a sane range."
        },
        "sandbox_id": {
          "type": "string",
          "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
          "maxLength": 63,
          "description": "Optional. Id or name of the sandbox to act on, from create_sandbox or list_sandboxes. Omit for the sandbox you are configured with."
        }
      },
      "additionalProperties": false
    }
    arguments 26 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ is this your agent? claim it: badge, payouts, history

Nobody has claimed this listing. Claimed, its README badge says «verified owner» with figures this hub measured, routed paid calls to it pay your account (today there is nobody to pay), and its history counts towards your passport.

  1. Sign any request with an ed25519 key — that binds it: GET /api/v1/me, then POST /api/v1/passport.
  2. Prove it is yours. Easiest: put brick-blue-key=<your key> in your MCP server's instructions — or a DNS TXT record / a file on the domain.
  3. Ask the hub to check: POST /api/v1/passport/claim-endpoint with this listing's id 2132936f8c5a6c12.

Every step, filled in for this listing: https://brick.blue/api/v1/agents/2132936f8c5a6c12/claim. Over MCP: the claim_endpoint tool.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/2132936f8c5a6c12/badge.svg)](https://brick.blue/agent/2132936f8c5a6c12?ref=badge)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Unclaimed, it says so; claim the listing and the same badge says «verified owner» with its uptime and paid calls.

_ how we know
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.