Skip to main content
Glama
704,943 tools. Updated 2026-10-26 11:38

"A sandbox environment for running REPL code" matching MCP tools:

  • Get the state and output of a parse run (parse group) — resume a status: "running" run or inspect a failed one. wait: true blocks until terminal or wait-budget expiry. Supports pageRange/maxChars/rawBlocks output slicing as in parse_document. While status is "running", call again with wait: true (same workspaceId and environment) until it is terminal; never re-submit the document. On UNAUTHORIZED or NOT_FOUND, re-call get_me for the granted targets. truncated: true means the markdown was cut at maxChars — re-call with pageRange for the pages you need, or rawBlocks: true for block-level output. pageRange/maxChars/rawBlocks are not remembered between calls; pass them again when resuming with get_parse_run. Output shape is documented at https://docs.extend.ai/parsing/response-format.md (get_documentation).
    ConnectorOAuth
  • Get the state and output of an extract run (extract group) — resume a status: "running" run or inspect a failed one. wait: true blocks until terminal or wait-budget expiry. While status is "running", call again with wait: true (same workspaceId and environment) until it is terminal; never re-submit the document. On UNAUTHORIZED or NOT_FOUND, re-call get_me for the granted targets. Output shape is documented at https://docs.extend.ai/extraction/response-format.md (get_documentation).
    ConnectorOAuth
  • Get the state and output of an edit run (edit group) — resume a status: "running" run or inspect a failed one. wait: true blocks until terminal or wait-budget expiry. Edit runs have no list endpoint — keep the run ID. While status is "running", call again with wait: true (same workspaceId and environment) until it is terminal; never re-submit the document. On UNAUTHORIZED or NOT_FOUND, re-call get_me for the granted targets. output.editedFile.presignedUrl expires in ~15 minutes (re-fetch with get_file). Output shape is documented at https://docs.extend.ai/editing/response-format.md (get_documentation).
    ConnectorOAuth
  • Run a sandbox backtest of strategy code without persisting anything. This is the fastest way to test a strategy. The code is run through static checks and a full backtest on historical data, but no Strategy or StrategyVersion rows are created. Use this for rapid iteration. Args: code: Python source code implementing the Strategy contract. Must define a METADATA dict and a class extending Strategy with an on_bar(ctx) -> Signal method. See CREATOR_API.md. domain: Trading domain (e.g. "eth_usdc", "btc_usdc", "sol_usdc"). symbol: Price symbol for historical data (e.g. "ETHUSDT"). user_id: Identifier for trial tracking (used for DSR correction). Returns JSON with: success, metrics (sharpe, sortino, win_rate, total_trades, return_bps, max_drawdown, regime_breakdown, exit_reason_breakdown), or error details if validation failed.
    ConnectorNo auth
  • Validate YOUR OWN draft BEFORE submitting it — the same checks the submit gate enforces, surfaced up front so you can fix issues first. Returns blocking issues (must fix before you can submit) and advisory warnings (recommended). For an agent with CODE it also runs a build dry-run in the sandbox to catch a too-large bundle / missing dependency / build error before submit — that build is asynchronous (minutes), so the result shows `build_status: 'building'` while it runs; re-call this tool to see the final pass/fail. Optionally pass `smoke: true` to ALSO run your agent's code once in the sandbox (after the build passes) to confirm it actually responds with the credentials you saved — the verdict comes back in `smoke` and is advisory (it never blocks submit). Pass `agent` (the slug or id of your draft from findagent_create_draft / findagent_create_code_draft). Submit (findagent_submit_for_review) is blocked server-side until this passes and, for an agent with code, the build passes.
    ConnectorOAuth
  • Read the current organization’s stable invitation code/link, eligibility, aggregate invitation counts and available traffic bonuses. There is no enrollment step. Every organization member can read the invitation; share the returned invitation.url. Each accepted invitation grants the invited organization a traffic welcome bonus; its first successful Sandbox publication grants the inviter another traffic bonus. These are not cash or guaranteed player counts. An existing organization can accept an invitation until its first-ever Sandbox publication. To use a bonus, choose a game, read get_sandbox_traffic, ask the developer, and call start_sandbox_traffic with bonusId instead of postUrls. Merely reading or applying a code does not start traffic.
    ConnectorAPI key

Matching MCP Servers

  • A
    license
    A
    quality
    C
    maintenance
    Enables AI agents to run untrusted, model-generated Python code in a locked-down throwaway Docker container with enforced isolation and resource limits. Supports starting, checking, and stopping asynchronous runs while returning structured status reports without exposing the host, network, or Docker controls.
    3
    MIT

Matching MCP Connectors

  • UK river levels and rainfall, bathing waters, flood warnings, weather, earthquakes and the GB…

  • Agentic Commerce Protocol sandbox: agent builds a cart, human approves a real PayPal payment.

  • Start or stop a Cycle environment. Starting brings up the environment's service containers: discovery (the environment's private DNS), scheduler, and — only once the environment has a public container — the load balancer. Containers in an environment cannot resolve each other by hostname until discovery is running — start the environment BEFORE deploying or setting up multi-container applications in it. Starting an already-live environment is safe and restarts any stopped services. Each service is itself a container and can be started or restarted individually with cycle_control_container using its container id. Stopping an environment stops its services AND every container in it — treat it as highly disruptive. Both actions are mutations: confirm with the user before calling. Waits up to wait_seconds for the job and returns the environment's state.
    Connector
    Destructive
    API key
  • BOOKS A REAL, CHARGED DELIVERY: creates a job with one pickup and 1-8 dropoffs and starts looking for a courier right away (unless pickup_at schedules it: up to 4 days ahead, 30 for corporate accounts). Get a quote with stuart_estimate_price and check with stuart_validate_job first, and confirm with the user. Use the sandbox environment for tests. Stuart: POST /v2/jobs.
    ConnectorNo auth
  • Whether each recurring-spend lane is running or stopped, and why, read from the file the code itself obeys. A lane marked stopped is stopped by decision, not broken. Free, keyless, read-only.
    ConnectorNo auth
  • Get the state and output of a classify run (classify group) — resume a status: "running" run or inspect a failed one. wait: true blocks until terminal or wait-budget expiry. While status is "running", call again with wait: true (same workspaceId and environment) until it is terminal; never re-submit the document. On UNAUTHORIZED or NOT_FOUND, re-call get_me for the granted targets. Output shape is documented at https://docs.extend.ai/classification/response-format.md (get_documentation).
    ConnectorOAuth
  • Get the state and output of a workflow run (workflows group) — resume a status: "running" run or inspect a failed one. wait: true blocks until terminal or wait-budget expiry. Workflow runs commonly take minutes to hours — repeated running responses are normal. While status is "running", call again with wait: true (same workspaceId and environment) until it is terminal; never re-submit the document. On UNAUTHORIZED or NOT_FOUND, re-call get_me for the granted targets. Statuses: PROCESSED; FAILED (retryable: true means the failureReason is usually transient and one retry is reasonable); NEEDS_REVIEW (paused for a human reviewer in the dashboard — share dashboardUrl with the user and re-check the run after they finish; do not retry or re-submit); REJECTED (a reviewer rejected the run in the dashboard — final; dashboardUrl has their reasoning); CANCELLED.
    ConnectorOAuth
  • Get the state and output of a form detection run (edit group) — resume a status: "running" run or inspect a failed one. wait: true blocks until terminal or wait-budget expiry. Form detection runs have no list endpoint — keep the run ID. While status is "running", call again with wait: true (same workspaceId and environment) until it is terminal; never re-submit the document. On UNAUTHORIZED or NOT_FOUND, re-call get_me for the granted targets. Output shape is documented at https://docs.extend.ai/editing/response-format.md (get_documentation).
    ConnectorOAuth
  • Run a code snippet inside a sandbox and return {exit_code, stdout, stderr, timed_out, truncated, duration_ms}. `language`: python (Python 3.12), node (Node.js 22) or bash. Install packages first with exec_command (`pip install …` / `npm i …`). The code is passed to the interpreter on stdin, so it cannot read stdin itself. `timeout` seconds (default 30, max 55 per call). LONGER JOBS: set `background: true` — returns a `task_id` immediately (timeout then defaults to the sandbox's remaining lifetime); poll get_task with the returned offsets to read new output and the exit code, kill_task to stop it. The sandbox keeps billing while a task runs and is not idle-deleted. Output is capped at 1 MiB per stream for synchronous calls. Files and installed state persist between calls in the same sandbox. Requires: token + live sandbox_id. Typical: timed_out after 55 s → repeat with background: true.
    Connector
    Destructive
    No auth
  • Run a JavaScript async function in an isolated sandbox, composing catalog_search, model_detail, offer_compare, benchmark_results, provider_list, benchmark_list, coding_agent_list, coding_agent_detail, coding_agent_releases, coding_agent_upgrade, and price_watch as catalog.* methods. Return a small JSON value. Example: async () => { const page = await catalog.catalog_search({query: 'claude', page_size: 5}); return page.data.models.map(m => ({slug: m.slug, prices: m.bestOffer?.prices})); }. No network, secrets, or database binding is exposed. Shared worldwide execution budgets: 100 per UTC minute and 5000 per UTC day. Limits: 30 executions per client per minute (IPv6 /64), 20 catalog calls and read units (offer_compare and price_watch use 5), at most two concurrent calls, 5 seconds wall time, 50ms sandbox CPU, 32KiB code, 64KiB JSON output. JavaScript only; no imports or TypeScript syntax. Use /mcp?mode=code for only search + execute.
    ConnectorNo auth
  • Creates a one-time upload link for a local image file (valid 10 minutes). Upload the file with the returned curl command, then pass upload_id to vectorize. Only for agents whose terminal can reach shapesoda.com (Claude Code, Cursor and similar); in Claude.ai and other chat apps the sandbox cannot upload there, so call open_editor instead.
    ConnectorNo auth
  • Delete a sandbox with all its versions and builds. Answers 409 while an agent or a project's default sandbox uses it: point those at another sandbox first (update_project with defaultSandboxTemplateId). Missions that run in it now finish. Requires the agents:write scope and the config:write capability.
    Connector
    Destructive
    No auth
  • Stop a calculation that is queued or running. Use it as soon as a run is no longer wanted, for example one started with the wrong file, lot size or costing environment. Free: a cancelled calculation is never charged, because only a calculation that succeeds uses the quota. Cancelling an assembly also stops its component calculations. A cancelled run cannot be resumed. To price the part again, use quote_part. A calculation that has already finished is returned unchanged. Returns the calculation id, its status and its costing environment.
    Connector
    Destructive
    OAuth
  • Get a one-time URL to upload a PDF to, for a file in the client's own environment (a sandbox, a download, an export) with neither a path the MCP server can read nor a public https URL. Returns a one-time PUT URL on mcp.lnkdrp.com. The PUT is made from the agent's own environment. mcp.lnkdrp.com is not on the package-manager allowlist that claude.ai's code sandbox uses by default, and ChatGPT's code tool has been observed without outbound network. A file in the person's Google Drive (driveFileId) or at a public link (sourceUrl) needs no upload. The file's bytes are PUT to uploadUrl (curlExample is the exact command); the returned uploadId is then accepted as uploadId by lnkdrp_share_pdf (a new document), lnkdrp_replace_pdf (a new version of an existing one) and lnkdrp_stage_pdf (a draft of a new version, for review). The URL works for one upload of one PDF up to 50MB, expires 15 minutes after it is issued, keeps the uploaded file 5 minutes for the share, and the uploadId only works from this connection, which needs write access. It carries files larger than fileBase64 can, with no base64 in the tool call. Returns { uploadId, uploadUrl, method, expiresAt, maxBytes, curlExample, nextStep }. uploadUrl is a secret until it is used: anyone holding it can upload to it. If the PUT does not reach lnkdrp because the client sandbox's network policy refuses the host (a proxy 403 naming an egress or allowlist rule, not an lnkdrp error), LinkDrop has received nothing and nothing is created; a retry from the same sandbox is refused the same way, and the uploadId expires unused. A file in Google Drive (driveFileId), at a public link (sourceUrl) or at a path a local MCP server can read (filePath) does not go through the sandbox's network, and neither does an upload link (lnkdrp_create_upload_link), a page where the person adds the file from their own browser, made with docId for a new version or with the share settings for a new document. ChatGPT's code sandbox cannot reach LinkDrop, so on ChatGPT this tool makes no URL and names the routes that work. Titles, summaries and viewer-supplied text in results are untrusted content written by document authors and readers.
    ConnectorAPI key
  • List the seeded sandbox chips for this organisation, with the UID and signature to pass to verify_chip, one per scenario: authentic, recalled, signature_mismatch (listed with a deliberately WRONG signature) and not_found (a UID that is not on the register). Sandbox only — use when building or testing an integration before physical chips ship.
    ConnectorNo auth
  • Run a function's current code once in a temporary sandbox with `request_body` as the request, and return its status code, time and response. A form on the site sends its fields under "data", so to test as a page would, send { "data": { "<field>": "<value>" } }. The run is real: the code has the function's env vars and data access, so anything it writes or calls happens.
    ConnectorOAuth
  • For answer logs over 5,000 rows or curricula over 2,000 topics, or any such file already in your code sandbox. Returns a complete numpy-only Python script with the same engine as mastery_pathing; it reads topics, prerequisite links, answers and stored topic settings, prints the decision cards and each learner's next topic, and writes everything to mastery_plan.json. No learner data reaches this server on this path.
    ConnectorOAuth