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.
JavaScript or TypeScript
→A durable sandbox
→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";consttext=fs.readFileSync("/data/orders.json","utf8");constrows=JSON.parse(text);constlate=rows.filter((row) =>row.daysOverdue >30);fs.mkdirSync("/out", { recursive:true });constids=late.map((row) =>row.id).join("\n");fs.writeFileSync("/out/late.csv", ids);constcount=`${late.length} of ${rows.length}`;console.log(`${count} orders are late`);
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 / 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 / 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…
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
DisposableDeterministicDurable
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.
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 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.
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.
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).
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 chart
PNG
Made by
shotcup:canvas
Program
87 lines
Input
/data/revenue.json, 590 bytes
File
/out/chart.png, 29,604 bytes
A real run, 1 November 2026. The picture: the file itself.
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.
33 lines, made by a JavaScript writer sent with the run (lib/xlsx.js, on shotcup:zip).
Output
/out/orders.xlsx, 43,542 bytes. The run printed “1000 orders, 6 regions”. A real run, 1 November 2026. The picture: its first sheet, rendered with LibreOffice and cropped.
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
session
5.2 s
Chart this week's signups from /data/signups.json as a bar chart PNG with the busiest day highlighted.
Fixed tasks. Up to 3 runs, no sign-up.
Steps
Plan
Code and runsucceeded in 28 ms
Answer
Result. Press Run to watch a live session.
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.
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.
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
/ month
Runs
Compute
Free
$0
30,000
3 h
Pro
$4.99
100,000
10 h
Scale
$14.99
300,000
30 h
Platform
$199
5,000,000
300 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.