boat vs GitHub Actions

GitHub Actions gives each CI job a fresh VM that GitHub removes when the job ends, at most 6 hours later. boat gives each agent a full VM that keeps its disk between runs, can run with no session cap once you turn auto-stop off, and can be reached from outside.

Where boat stands out

A machine that stays

A boat sandbox keeps its disk between runs. boat saves the disk every minute and at each stop, and keeps a stopped sandbox's disk for at least 14 days. A stopped sandbox has no compute charge. Memory and running programs are not saved, so a resume is like a reboot. You can also fork a running sandbox to try two ideas from the same state.

Reach it from outside

You can SSH into a boat sandbox, open token-gated HTTPS URLs on up to 50 ports and watch its desktop at 60 fps. An agent can run a dev server or an app, and you, a test or a user can use it while it runs.

Agents you drive from any program

Claude Code, Codex and five other agent harnesses are installed. You prompt, steer and follow them through one API from any program, not only from issues and pull requests. With the optional credentials proxy on, the real keys of supported model providers stay outside the sandbox.

The companies and products

boat

boat.dev runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.

You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.

GitHub Actions

GitHub Actions is GitHub's CI/CD service: workflows in your repository run as jobs on runners that GitHub hosts or that you host yourself.

GitHub Actions is a CI service, not a general sandbox API. Each job on a GitHub-hosted runner gets a new VM with passwordless sudo, and GitHub removes the VM when the job ends. Windows and larger runners run on Azure, standard Linux runners run on a multi-cloud pool, and macOS runs on GitHub's own Mac fleet. The 1-CPU slim runner is a container, not a VM. Actions is built to build, test and deploy the code in a repository. The Copilot cloud agent runs on Actions runners when you start it from the web or Copilot Chat. The newer Copilot in the cloud runs in a Copilot cloud sandbox by default: an isolated Linux session that keeps a snapshot when it stops.

Which use cases each one fits

For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “5th cheapest of 365” means 4 of the other 364 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.

Use case and its workloadboat: price rankGitHub Actions: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
A software factory needs agents that keep their checkout, Docker cache and services between tasks. On Actions you set it up: restore them from the cache, artifacts or a larger-runner custom image at each job, inside the 6-hour limit.
5th cheapest of 365
$634 a month
304th of 365, with limits
$5,553 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
An assistant that lives on its machine all month does not fit jobs that end within 6 hours. On Actions you set it up: schedule new jobs and carry state through the cache or artifacts.
6th cheapest of 361
$657 a month
151st of 361, with limits
$12,882 a month
Code interpreter bursts
100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month
Each job waits for a fresh VM and bills at least one minute, which suits builds better than many tiny code runs.
189th of 336, with limits
$2,000 a month
288th of 336, with limits
$721 a month
Sandboxes for your users
300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month
GitHub's terms do not allow offering Actions to your own users as a service, and hosted runners take no public inbound traffic.
3rd cheapest of 349
$209 a month
302nd of 349, with limits
$2,892 a month
RL rollouts
1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month
39th of 349, with limits
$2,000 a month
297th of 349, with limits
$14,721 a month
Agent evals
250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month
10th cheapest of 359
$200 a month
299th of 359, with limits
$1,662 a month
CI runners
40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month
Both fit. GitHub Actions is the native choice for a GitHub repository's CI. boat suits CI that needs a warm disk between runs or jobs longer than 6 hours.
2nd cheapest of 374
$86 a month
85th cheapest of 374
$729 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
A dev box needs SSH, open ports and a disk that stays. On Actions you set it up: a third-party SSH or tunnel action gives a session inside a job, and the job still ends within 6 hours.
19th cheapest of 371
$26 a month
253rd of 371, with limits
$71 a month
Computer-use agents
50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month
Runners have no desktop stream. You set it up: install a virtual display such as Xvfb in the job and record screenshots or video. boat streams a desktop at 1920x1080, 60 fps, with computer tools for agents.
7th cheapest of 367
$200 a month
306th of 367, with limits
$1,502 a month
Browser-use agents
50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month
7th cheapest of 356
$200 a month
198th of 356, with limits
$942 a month
Scraping & bots (startup scale)
50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month
6th cheapest of 343
$90 a month
202nd of 343, with limits
$1,184 a month
Mass scraping & bots (undetectable)
1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month
73rd of 327, with limits
$1,800 a month
296th of 327, with limits
$28,971 a month
Parallel red teaming
200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month
3rd cheapest of 351
$200 a month
123rd of 351, with limits
$467 a month
GPU eval jobs
10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month
Not ranked: misses a requirementNot ranked: misses a requirement
macOS agents
5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month
GitHub Actions has hosted macOS runners on Apple silicon and Intel. boat runs Linux only.
Not ranked: misses a requirement23rd of 35, with limits
$1,178 a month

Key features

FeatureboatGitHub Actions
Kind of productSandbox API: create, stop, fork and reach machines from your codeCI service: jobs run from workflow files in a GitHub repository
IsolationFull VM with its own kernel, root and systemd, on physical hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are sharedNew VM per job with passwordless sudo; Windows and larger runners on Azure, standard Linux on a multi-cloud pool, macOS on GitHub's Mac fleet
Session lengthAuto-stop defaults to 1 hour; set up to 30 days, or turn it off on a paid plan for no session capUp to 6 hours per job
Disk between runsDisk saved every minute and at each stop; kept at least 14 days after a stop. Memory and running programs are not savedEach job starts on a fresh VM. You set it up: carry files through the cache or artifacts, or save a larger runner's disk as a custom image with the `snapshot` keyword
ForkFork a running sandbox from its last 1-minute snapshot; writes from the last minute can be missingNo live fork; a larger-runner job can save its disk as a custom image with the `snapshot` keyword when it completes, and new jobs start from that image
Copilot cloud sandboxesAny program can create, stop and resume sandboxes through the APIIsolated Linux sessions that keep a snapshot when stopped and resume with files intact, billed per second; GitHub creates them for Copilot sessions only
Nested virtualizationYes, /dev/kvm for Android emulators and VMsYes on Linux runners, including the 2-vCPU ones, after you add the runner user to the KVM group
Inbound accessSSH, up to 50 token-gated HTTPS URLs, a public IPv6 address; raw ports on sandboxes without their own IPv4 work over IPv6 only; the IP changes at each resumeNo public inbound access; runners joined to your Azure network can be reached only from inside that network
Desktop and computer useLinux desktop and Chrome streamed at 1920x1080, 60 fps, with computer tools for agentsNo desktop stream; browsers are preinstalled for tests. You set it up: a virtual display such as Xvfb for screenshots and recordings
Coding agentsSeven agent harnesses installed in your sandbox, driven from any program with a prompt, steer and events APICopilot cloud agent, plus Claude and Codex in public preview, working on issues and pull requests; a REST API in public preview starts Copilot tasks
Keeping API keys out of the machineOptional AI credentials proxy ($1 per day it is on plus $1 per 1,000 requests); with it on, supported providers' real keys never enter the sandbox. Other secrets and environment variables still doSecrets enter the job as inputs or environment variables and are hidden from logs; OIDC gives short-lived cloud tokens
Operating systemsLinux x64; Windows programs only through WineLinux x64 and arm64, Windows x64 and arm64, macOS
GPUsNone on any sizeLinux and Windows larger runners with an NVIDIA T4
Regions and networkingGermany, Finland and France, no region choice and no US or Asia region; open internet; no static IPLarger runners can get static IP ranges, or join your Azure private network in regions across the US, Europe and APAC; standard Linux runners use a multi-cloud pool
ComplianceSOC 2 in progress; no SOC 2 report todaySOC 1 and SOC 2 Type 2 reports, ISO/IEC 27001:2022
Self-hostingNoOpen-source runner on your own machines, free to use today
Compliance and transparencySOC 2 is in progress. We're open about where we stand: live status and data retention policy.SOC 2
Every feature Battleships tracks (43)
FeatureboatGitHub Actions
Full VM (own kernel)YesYes
Docker insideYesYes
Nested virtualizationYesYes
RootYesYes
SystemdYesNo documented way
Desktop GUIYesNo documented way
BrowserYesYes
Computer-use APIYesNo documented way
SSHYesNo documented way
Persistent diskYesNo documented way
Pause/resumeYesNo documented way
Automatic snapshotsYesNo documented way
Fork/cloneYesNo documented way
Live fork (no pause)YesNo documented way
Memory forkNo documented wayNo documented way
Custom image (Docker or snapshot)YesYes
≥24 h sessionsYesNo documented way
Idle auto-stopNo documented wayYes
Wake on requestNo documented wayNo documented way
HTTPS preview URLsYesNo documented way
Raw TCP inboundYesNo documented way
Public IPv4No documented wayNo documented way
Egress allowlistNo documented wayYes
Secret proxyYesNo documented way
Secret proxy for any APIYesNo documented way
Preinstalled agentsYesYes
Agent harness APIYesYes
MCP serverNo documented wayYes
GPUNo documented wayYes
WindowsNo documented wayYes
Arm64No documented wayYes
Self-hostingNo documented wayYes
BYOCNo documented wayNo documented way
Open sourceNo documented wayYes
Scoped API keysYesNot published
Spend limitsYesYes
Usage per sandbox (API)YesYes
Audit logsNo documented wayYes
SSONo documented wayYes
SOC 2No documented wayYes
HIPAANo documented wayNo documented way
EU data residencyNo documented wayYes
Zero data retentionYesNot published

Performance

boat28.06 runs/s
GitHub ActionsNot measured

GitHub Actions hosted runners are not in the public benchmarks we use, so we cannot say which is faster. For reference, boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15 in StarSling's run of 3 October 2026 (run 37073680030). Every boat sandbox in that run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure.

V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. GitHub Actions is not in the public benchmarks we use, so we cannot say which is faster.

Pricing in five scenarios

Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario. Start limits, per-start fees and plan minimums are in the price, boat's included.

Scenarioboat, a monthGitHub Actions, a month
One coding agent, workdays
4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days
$20 · $20/mo$21 · Enterprise Cloud · with limits
One agent that never stops
4 vCPU / 8 GB, 50 GB disk, running 24/7 all month
$26 · $20/mo$71 · Enterprise Cloud · with limits
50 agents in parallel
50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside
$317 · $20/mo × 3 seats$3,565 · Enterprise Cloud · with limits
Sandboxes for your users
2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once
$200 · $100/mo × 2 seats$1,092 · Enterprise Cloud · with limits
1,000 short jobs at once
2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month
$8,800 · $2000/mo · with limits$2,721 · Enterprise Cloud · with limits

boat: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. Included VM time does not carry over. A default sandbox (4 vCPU / 8 GB) costs $0.036 an hour, billed per second while it runs, busy or idle. A stopped sandbox has no compute charge; saved snapshots above the included count and the AI credentials proxy still charge. The $20 plan allows 100 sandboxes at once and 12 starts a minute, 60 an hour and 200 a day; extra starts cost $0.03 to $0.07 each.

GitHub Actions: GitHub bills per minute per job, rounding each job up to the next whole minute, at a rate set by the runner type, from $0.006 a minute for 2-core Linux. Each plan includes a monthly compute amount in dollars ($12 Free, $18 Pro and Team, $300 Enterprise Cloud), shared with Copilot cloud sandboxes. It covers standard runners, and larger runners can draw from it on Team and Enterprise. Public repositories use standard runners for free.

Limits in those scenarios

GitHub Actions is a CI service, so it does not fit the agent scenarios on this page as a sandbox. Every job ends within 6 hours. On standard runners nothing on the disk carries to the next job unless you save it to the cache or artifacts; a larger runner can save its disk as a custom image when the job completes. For sandboxes for your users, GitHub's terms rule out offering Actions as a service. For 1,000 short jobs at once, Enterprise standard runners stop at 500 concurrent jobs; larger runners on Team and Enterprise allow 1,000, and GitHub Support can raise limits. boat's $2,000 plan allows 2,000 sandboxes at once and 90 included starts a minute; above that, extra starts cost $0.03 to $0.07 each, and above 3 times the included number per minute a start fails with 429. boat never queues a start.

ScenarioboatGitHub Actions
One coding agent, workdaysNone for this scenario
  • Enterprise Cloud: sessions capped at 6 h
  • different kind of product: CI runner
One agent that never stopsNone for this scenario
  • Enterprise Cloud: sessions capped at 6 h
  • different kind of product: CI runner
50 agents in parallelNone for this scenario
  • Enterprise Cloud: sessions capped at 6 h
  • different kind of product: CI runner
Sandboxes for your usersNone for this scenario
  • different kind of product: CI runner
1,000 short jobs at once
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429
  • Enterprise Cloud: max 500 concurrent
  • different kind of product: CI runner
  • needs talk to sales: above plan "Enterprise Cloud" limits: contact sales for more
boat's own limits
  • Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
  • Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
  • A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
  • Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
  • boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
  • Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
  • Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
  • Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source

Which one should you use?

Use GitHub Actions when

you want Copilot, Claude or Codex working on your issues and pull requests.

  • Native CI for GitHub repos. For building and testing a GitHub repository, Actions runs right from pull requests and pushes with no extra service to connect.
  • Copilot cloud sandboxes. Copilot sessions get isolated Linux sandboxes that keep their files between sessions.
  • macOS, Windows, arm64 and GPUs. Teams that build for Apple, Windows or arm64, or need a T4 GPU, get hosted runners for each.
  • Your own runners and your own network. You can run the open-source runner on your own machines for free, or give larger runners static IP ranges or your Azure network.

Use boat when

an agent needs its own Linux machine that keeps its disk between runs, runs past 6 hours, takes inbound traffic and shows a desktop.

  • A machine that stays. On GitHub Actions each job starts on a clean VM and ends within 6 hours. An agent restores its tools and repo from the cache, artifacts or a custom image at each job, and work past 6 hours is split across jobs.
  • Reach it from outside. Hosted runners take no public inbound connections. A preview, a webhook or a live look at the agent needs a third-party tunnel inside the job.
  • Agents you drive from any program. In an Actions job, secrets arrive as inputs or environment variables inside the VM that the agent controls. Hiding them from logs does not stop a prompt injection from reading them.

Questions people ask

Can I use GitHub Actions as a sandbox for AI agents?

For agent work on a repository, yes. The Copilot cloud agent runs on Actions runners when you start it from the web or Copilot Chat, and the newer Copilot in the cloud runs in a Copilot cloud sandbox by default. An Actions job is a fresh VM that ends within 6 hours and takes no public inbound traffic. GitHub's terms limit hosted runners to work on the repository's software project.

Is boat cheaper than GitHub Actions?

For machines that run for hours, yes: a boat default sandbox (4 vCPU / 8 GB) costs $0.036 an hour, and a 2-core Linux runner costs $0.006 a minute ($0.36 an hour). But Actions jobs end within 6 hours, so they are not a full match for agent sandboxes. For plain CI on a GitHub repository, free standard runners on public repos and the included monthly usage ($12 on Free) can make Actions cheaper. boat's smallest plan is $20 a month.

How long can a GitHub Actions job run?

Up to 6 hours per job on GitHub-hosted runners, and 15 minutes on the single-CPU slim runners. A boat sandbox auto-stops after 1 hour by default. You can set up to 30 days, or turn auto-stop off on a paid plan for no session cap.

Do files persist between GitHub Actions runs?

Not on a standard runner: each job starts on a new VM. You set it up: carry files through the cache or artifacts, or save a larger runner's disk as a custom image with the `snapshot` keyword. A boat sandbox keeps its disk: boat saves it every minute and at each stop, and keeps it at least 14 days after a stop. Memory and running programs are not saved.

Can I run Docker and Android emulators in each?

Both run Docker, and both expose KVM on Linux for Android emulators. On GitHub runners you add the runner user to the KVM group first, and the job still ends within 6 hours.

Is boat SOC 2 compliant?

No, not today. SOC 2 is in progress. Live status is at status.ascii.dev and our data retention policy is at docs.boat.dev/data-retention.

Start a sandbox

Install the CLI, then run boat new.

7-day free trial

More comparisons