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.
- Isolation
- Full VM per sandbox, own kernel
- Regions
- EU: Germany, Finland, France
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.
- Included usage
- A monthly dollar amount: $12 on Free, $18 on Pro and Team, $300 on Enterprise Cloud, shared with Copilot cloud sandboxes
- Copilot cloud sandboxes
- Isolated Linux sessions for Copilot that keep a snapshot when stopped, billed per second; GitHub creates them for Copilot sessions only
- Self-hosted runners
- Open-source runner under MIT; usage on self-hosted runners is free today
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 workload | boat: price rank | GitHub 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 requirement | Not 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 requirement | 23rd of 35, with limits $1,178 a month |
Key features
| Feature | boat | GitHub Actions |
|---|---|---|
| Kind of product | Sandbox API: create, stop, fork and reach machines from your code | CI service: jobs run from workflow files in a GitHub repository |
| Isolation | Full VM with its own kernel, root and systemd, on physical hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared | New 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 length | Auto-stop defaults to 1 hour; set up to 30 days, or turn it off on a paid plan for no session cap | Up to 6 hours per job |
| Disk between runs | Disk saved every minute and at each stop; kept at least 14 days after a stop. Memory and running programs are not saved | Each 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 |
| Fork | Fork a running sandbox from its last 1-minute snapshot; writes from the last minute can be missing | No 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 sandboxes | Any program can create, stop and resume sandboxes through the API | Isolated Linux sessions that keep a snapshot when stopped and resume with files intact, billed per second; GitHub creates them for Copilot sessions only |
| Nested virtualization | Yes, /dev/kvm for Android emulators and VMs | Yes on Linux runners, including the 2-vCPU ones, after you add the runner user to the KVM group |
| Inbound access | SSH, 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 resume | No public inbound access; runners joined to your Azure network can be reached only from inside that network |
| Desktop and computer use | Linux desktop and Chrome streamed at 1920x1080, 60 fps, with computer tools for agents | No desktop stream; browsers are preinstalled for tests. You set it up: a virtual display such as Xvfb for screenshots and recordings |
| Coding agents | Seven agent harnesses installed in your sandbox, driven from any program with a prompt, steer and events API | Copilot 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 machine | Optional 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 do | Secrets enter the job as inputs or environment variables and are hidden from logs; OIDC gives short-lived cloud tokens |
| Operating systems | Linux x64; Windows programs only through Wine | Linux x64 and arm64, Windows x64 and arm64, macOS |
| GPUs | None on any size | Linux and Windows larger runners with an NVIDIA T4 |
| Regions and networking | Germany, Finland and France, no region choice and no US or Asia region; open internet; no static IP | Larger 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 |
| Compliance | SOC 2 in progress; no SOC 2 report today | SOC 1 and SOC 2 Type 2 reports, ISO/IEC 27001:2022 |
| Self-hosting | No | Open-source runner on your own machines, free to use today |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | SOC 2 |
Every feature Battleships tracks (43)
| Feature | boat | GitHub Actions |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | Yes |
| Root | Yes | Yes |
| Systemd | Yes | No documented way |
| Desktop GUI | Yes | No documented way |
| Browser | Yes | Yes |
| Computer-use API | Yes | No documented way |
| SSH | Yes | No documented way |
| Persistent disk | Yes | No documented way |
| Pause/resume | Yes | No documented way |
| Automatic snapshots | Yes | No documented way |
| Fork/clone | Yes | No documented way |
| Live fork (no pause) | Yes | No documented way |
| Memory fork | No documented way | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | No documented way |
| Idle auto-stop | No documented way | Yes |
| Wake on request | No documented way | No documented way |
| HTTPS preview URLs | Yes | No documented way |
| Raw TCP inbound | Yes | No documented way |
| Public IPv4 | No documented way | No documented way |
| Egress allowlist | No documented way | Yes |
| Secret proxy | Yes | No documented way |
| Secret proxy for any API | Yes | No documented way |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | Yes |
| MCP server | No documented way | Yes |
| GPU | No documented way | Yes |
| Windows | No documented way | Yes |
| Arm64 | No documented way | Yes |
| Self-hosting | No documented way | Yes |
| BYOC | No documented way | No documented way |
| Open source | No documented way | Yes |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Yes |
| Usage per sandbox (API) | Yes | Yes |
| Audit logs | No documented way | Yes |
| SSO | No documented way | Yes |
| SOC 2 | No documented way | Yes |
| HIPAA | No documented way | No documented way |
| EU data residency | No documented way | Yes |
| Zero data retention | Yes | Not published |
Performance
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.
| Scenario | boat, a month | GitHub 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.
| Scenario | boat | GitHub Actions |
|---|---|---|
| One coding agent, workdays | None for this scenario |
|
| One agent that never stops | None for this scenario |
|
| 50 agents in parallel | None for this scenario |
|
| Sandboxes for your users | None for this scenario |
|
| 1,000 short jobs at once |
|
|
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
- boat vs Bitrise
- boat vs Buildkite
- boat vs Blacksmith
- boat vs CircleCI
- boat vs Codemagic
- boat vs Depot
- boat vs GitLab.com hosted runners
- boat vs WarpBuild
- boat vs E2B
- boat vs Daytona
- boat vs Modal
- boat vs Vercel Sandbox
- GitHub Actions vs CircleCI
- GitHub Actions vs Blacksmith
- GitHub Actions vs Depot
- GitHub Actions vs WarpBuild
- GitHub Actions vs Buildkite
- GitHub Actions vs GitLab.com hosted runners
- GitHub Actions vs Bitrise
- GitHub Actions vs Codemagic