Skip to content

Let your agents do real work.

JavaScript and TypeScript in, deterministic artifacts out. Shotcup runs your agents’ and customers’ code in a durable sandbox and returns the same charts, documents and data every time.

  1. JavaScript or TypeScript
  2. A durable sandbox
  3. A deterministic artifact

What a run works with. Point at one to see a real run.

An artifact is a file the run hands back for people or programs, such as a chart, a PDF, a spreadsheet or a data file. It is not a build output. With determinism on (the default) and no network, the same code and files give the same bytes on the same Shotcup version.

POST /api/v1/runsmain.js + data/orders.json
import fs from "fs";
const text = fs.readFileSync("/data/orders.json", "utf8");
const rows = JSON.parse(text);
const late = rows.filter((row) => row.daysOverdue > 30);
fs.mkdirSync("/out", { recursive: true });
const ids = late.map((row) => row.id).join("\n");
fs.writeFileSync("/out/late.csv", ids);
const count = `${late.length} of ${rows.length}`;
console.log(`${count} orders are late`);

200 OK

A real run, 18 October 2026.

status
succeeded
stdout
2 of 3 orders are late
diff
create /out/late.csv, 9 bytes
files
/out/late.csv, inline and as a link

/out/late.csv (9 bytes)

  • 1042
  • 1043

Why a run is enough

Your agent rarely needs a full computer. It needs somewhere to run the code it wrote and a result it can trust. That’s Shotcup.

How a run behaves

  1. 1 / 3

    Disposable

    Every run starts fresh in a few milliseconds and leaves nothing behind.

    Two runs, one after the other: the second finds nothing the first wrote.

    POST /api/v1/runs

    Two real runs, 1 November 2026.

    run 1succeeded, ran for 5.25 ms, wrote /out/note.txt

    run 2succeeded, printed “no /out/note.txt”

  2. 2 / 3

    Deterministic

    The same code and files give the same result: a fixed clock and seeded randomness, by default.

    With determinism on (the default), no network and the same Shotcup version, two runs write the same bytes.

    deterministic: true (the default)

    Two real runs, 1 November 2026.

    stdoutclock 0, first draw 0.8833 (both runs)

    run 1/out/bars.png, SHA-256 df80b4ceb9bce9b2…

    run 2/out/bars.png, SHA-256 df80b4ceb9bce9b2…

    seed 7 · clock 0
  3. 3 / 3

    Durable

    A run is a record you can pick up again: a paused run resumes by its id, from any process.

    This run paused at a tool call that needs approval, and another process resumed it by its id.

    POST /api/v1/runs/:id/resume

    A real run and its resume, 1 November 2026.

    runinterrupted at refunds.approve, call c1

    resumeby its id from another process: succeeded

    stdoutrefunded A-1001

Who it’s for, and what you get

Shotcup is a JavaScript and TypeScript sandbox for the code your agents and customers write, and for the programs that turn your data into files.

Code your agent writes

Claude Code, Claude Desktop, Codex, Cursor, VS Code, Grok and any MCP client that can send a header connect with one API key; an agent you build calls the same runs over the REST API or code mode. Each run starts fresh in milliseconds, hands back its files as links and can pause for a person or a tool and resume later by its id.

MCP setup for every clientCode modeVercel AI SDK

Code your customers write

Each of your customers gets a tenant with its own keys and quotas, files served from your own domain, and a statement each month. Every script runs in its own sandbox, with limits per run and nothing shared between runs.

The Platform planPlans and limits

Files from your data

The data goes to the run as a file, never through the model: a short program turns a thousand rows into a chart, a report or a spreadsheet, and by default the same data gives the same file.

Files and documents from a run

When Shotcup fits

  • The code is JavaScript or TypeScript that an agent, a customer or a person wrote, and a run takes milliseconds to minutes.
  • You want the same result from the same code and files: a fixed clock and seeded randomness by default, and a diff of every file a run changed.
  • You want files back, not only text: PNG, JPEG, GIF, HTML and ZIP, and PDF, Word, Excel and PowerPoint through JavaScript writers sent with the run.
  • Your data is too big to pass through a model: the run reads it as a file and writes the result.
  • You want a run to wait for a person or a tool and carry on later.
  • A job that needs an operating system, packages installed from npm, Python or a browser belongs on a whole machine: the comparison shows the options.

Where Shotcup is today

  • Live: the API, the MCP server and the sandboxes run on shotcup.dev in the EU, with a public status page.
  • Free is open: 30,000 runs and 3 compute-hours a month, for personal and non-commercial use. No card needed.
  • Try a paid plan: Choose one free 14-day trial of Pro, Scale or Platform per account, with no card. Start from your dashboard’s Billing page.
  • Paid plans open with billing: Pro, Scale and Platform are priced below and can be bought once billing launches.
  • Packages: the REST API and the MCP server work from any language today. The TypeScript SDK and the packages for the Vercel AI SDK and eve are documented and not on npm yet.

Code mode, hosted and durable

One script instead of many model turns

The model writes one short program that calls your tools as functions. Shotcup runs it, and only the result goes back to the model. The libraries it uses travel with it as files, so nothing is installed and a run starts in milliseconds.

main.js
const rows = await tools.crm.listCustomers({
  segment: "enterprise",
});
const late = rows.filter((row) => row.daysOverdue > 30);
await tools.mail.draft({ to: late.map((row) => row.email) });
console.log(`${late.length} reminders drafted`);

Answer tool calls live over a stream, or pause the run at a call and answer later.

What code mode is and how to run itCode mode with the Vercel AI SDK

When a run has to wait, it carries on from its record

Shotcup keeps a paused run’s record, so the run can stop for a person or a tool and carry on later without anything being guessed.

It resumes by its id
Send the answers by the run’s id, from any process, minutes or hours later.
It is replayable
A resumed run gets its recorded answers. A call that differs from its record stops the run and names the call.
A retry gets the first attempt’s run
An Idempotency-Key gives a retry the run the first attempt started, unless that run never ran or was lost. A run interrupted in the middle is not resumed: your workflow engine retries it from the start, so a tool that changes something outside should cope with a second call. A second resume of one pause is refused (409).
Resume with the answer
curl https://shotcup.dev/api/v1/runs/$RUN_ID/resume \
  -H "Authorization: Bearer $SHOTCUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"results": [{"callId": "'"$CALL_ID"'", "value": {"approved": true}}]}'

How durable code mode works

What a run hands back

Every file below is an artifact from a real run: a chart, a document, a spreadsheet or an archive the run handed back, not a build output. The program went in, the run wrote the file under /out, and the answer carried it back. Images and ZIPs come from Shotcup’s own modules; PDF, Word, Excel and PowerPoint files from JavaScript writers sent with the run.

A thousand rows in, a chart and a spreadsheet out

The data goes to the run as a file, never through the model: a short program turns a thousand rows into a chart, a report or a spreadsheet.

Both runs were sent the same thousand orders as /data/orders.csv, a file in the request. A model only has to write the program; the rows never pass through it, and the answer carries the file the program wrote.

Files and documents from a run: every type and how it comes back

Watch an agent use it

A model writes the code, Shotcup runs it, and you see every step with its timings. When a run fails, its answer says why, with a hint when the fix is known, and the agent repairs its own code and runs it again. No sign-up needed.

Watch an agent use Shotcup

Recorded with Claude Haiku 5.5 on shotcup.dev, 20 October 2026

5.2 s

Chart this week's signups from /data/signups.json as a bar chart PNG with the busiest day highlighted.

Pick a task for the agent

Fixed tasks. Up to 3 runs, no sign-up.

  1. Plan
  2. Code and runsucceeded in 28 ms
  3. Answer

Result. Press Run to watch a live session.

The recorded run's result, /out/signups.png: a bar chart of signups per day in 2026-W41, with Friday's 97 highlighted

Friday was busiest with 97 signups out of 395 this week; the bar chart is saved as /out/signups.png.

in the sandbox
28 ms
last run, server
672 ms
Shotcup runs
1
model calls
2

Compute for agents, not computers for agents

Most agent code reads some data, calls a few tools and writes a file. Shotcup runs that code without a machine to boot, keep warm or clean up, which is why a run starts in milliseconds and you pay for a run, not a machine-minute.

How fast it is, and when we measured it

Every figure was measured on shotcup.dev and says when and how.

A run on the run endpoint, p50
5.9ms
p95 6.7 ms. Server time, opt-in while it is new. 300 runs from London, 9 October 2026.
A run through the API, p50
85.7ms
p95 103.8 ms. Server time, including the account and quota checks. 300 runs from London, 9 October 2026.
A 1200 × 630 social card with emoji, p50
64.1ms
Drawn in the sandbox on shotcup.dev, 8 October 2026, 20 runs.

Every measurement and how it was taken

Why you can trust a run

What every run gets, and how the parts that read your files are tested.

  • Each run is sealed: a fresh engine and filesystem, hard limits on time, memory and work, and no network unless you name the hosts it may reach (Free runs have none). A run that crashes ends alone, and the next run starts on a fresh engine.
  • Shotcup’s own PNG and ZIP readers are tested against hostile files and 10,000 mutated ones under a memory checker whenever the runtime changes, and the font reader against hostile fonts and mutated ones, before a change ships.
  • Modern TypeScript and JavaScript run as written. Shotcup is built on GocciaScript, the open-source JavaScript engine we develop alongside it, which runs the official ECMAScript conformance suite and more than 12,000 tests of its own on every change.

One key for REST, MCP and the SDK

Any MCP client that can send a header connects with one key: Claude Code, Claude Desktop, Codex, Cursor, VS Code and Grok among them. Or sign in from claude.ai, ChatGPT, Claude Code, Cursor or VS Code. Everything else calls the REST API.

MCP setup for every clientQuickstart

Claude Code
claude mcp add --transport http shotcup https://shotcup.dev/mcp \
  --header "Authorization: Bearer $SHOTCUP_API_KEY"
REST
curl https://shotcup.dev/api/v1/runs \
  -H "Authorization: Bearer $SHOTCUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"code": "console.log(1 + 1);"}'

Start on Free, move up when you need more

Every plan includes a monthly allowance of runs and compute-hours. Free is for personal, non-commercial use only; commercial use needs a paid plan or a trial of one.

Plans: price and monthly allowance
Plan/ monthRunsCompute
Free$030,0003 h
Pro$4.99100,00010 h
Scale$14.99300,00030 h
Platform$1995,000,000300 h

Free

$0/ month

Open now

Runs / month
30,000
Compute-hours
3 h
Concurrent runs
1
Longest run
5 s

Pro

$4.99/ month

or $49 / year

Opens with billing

Runs / month
100,000
Compute-hours
10 h
Concurrent runs
10
Longest run
30 s

Scale

$14.99/ month

or $149 / year

Opens with billing

Runs / month
300,000
Compute-hours
30 h
Concurrent runs
50 (4 large)
Longest run
5 min

Platform

$199/ month

or $1,990 / year

Opens with billing

Runs / month
5,000,000
Compute-hours
300 h
Concurrent runs
100 (4 large)
Longest run
5 min

Prices in US dollars, including VAT/sales tax where applicable.

Custom needs? Contact us at sales@shotcup.dev

Every limit, side by side

Give your agent somewhere to run its code

Free includes 30,000 runs a month. One API key works for REST, MCP and the SDK.