GitLab.com hosted runners vs Ubicloud
GitLab.com hosted runners run the CI jobs of GitLab projects, each on a fresh VM that is deleted within 3 hours. Ubicloud is an open source cloud that rents plain Linux VMs you keep, set up and run yourself, plus GitHub Actions runners.
The companies and products
GitLab.com hosted runners
GitLab.com hosted runners are the machines that run GitLab CI/CD jobs for projects on GitLab.com, paid for in compute minutes.
This is a CI service, not a sandbox API. Each job gets a new VM on Google Cloud (Linux and Windows) or on AWS Mac hardware (macOS), with passwordless sudo, and the VM is deleted right after the job. It is built for building, testing and deploying the code in a GitLab project, and GitLab's Duo Agent Platform also runs Claude Code and Codex agents as CI/CD jobs on these runners.
Ubicloud
Ubicloud is an open source cloud that runs VMs, managed Postgres, Kubernetes and GitHub Actions runners on leased bare-metal servers.
You rent Linux VMs (Standard with dedicated CPU, or cheaper Burstable with shared CPU) from Ubicloud's managed service, or run the same AGPL code on your own servers. Around the VMs it offers private subnets, an inbound firewall, load balancers, managed PostgreSQL, Kubernetes, GPU VMs, inference endpoints and cheap GitHub Actions runners. It is general infrastructure, not an agent sandbox, so this page compares the two where they overlap: giving an agent its own Linux machine.
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. “128th cheapest of 377” means 127 of the other 376 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 | GitLab.com hosted runners: price rank | Ubicloud: price rank | boat: 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 and services between tasks, which a 3-hour GitLab job cannot give; a Ubicloud VM can, but you set up the agents and pay while it is stopped. | 347th of 367, with limits $14,454 a month | 126th of 367, with limits $1,136 a month | 3rd cheapest of 367 $634 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 3-hour GitLab jobs; a Ubicloud VM can run it around the clock, and boat has the agent setup, HTTPS link and snapshots built in. | 353rd of 366, with limits $21,858 a month | 154th of 366, with limits $1,139 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month | 320th of 345, with limits $1,896 a month | 59th of 345, with limits $52 a month | 186th of 345, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month GitLab's runners only run jobs from GitLab pipelines and take no inbound traffic; Ubicloud's default quota of 256 vCPU needs a raise from support for 300 user sandboxes of 2 vCPU. | 331st of 361, with limits $6,133 a month | 53rd of 361, with limits $390 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 318th of 360, with limits $29,762 a month | 234th of 360, with limits $1,560 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 330th of 364, with limits $4,758 a month | 31st cheapest of 364 $624 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both fit CI: GitLab's runners are the native choice for GitLab pipelines, Ubicloud sells GitHub Actions runners billed per minute, and boat runs CI on general sandboxes with Docker and /dev/kvm. | 128th cheapest of 377 $2,089 a month | 28th cheapest of 377 $300 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs SSH and a disk that stays: GitLab's hosted runners have neither, while a Ubicloud Standard VM gives dedicated CPU and boat keeps its disk with snapshots every minute. | 358th of 368, with limits $805 a month | 67th cheapest of 368 $91 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month GitLab's runners are headless and Ubicloud VMs come with no desktop, while boat streams a 60fps desktop with Chromium and computer use built in. | 342nd of 369, with limits $4,278 a month | 132nd of 369, with limits $312 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 144th of 367, with limits $2,118 a month | 188th of 367, with limits $156 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 143rd of 346, with limits $2,854 a month | 165th of 346, with limits $78 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 319th of 338, with limits $58,429 a month | 60th of 338, with limits $1,573 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 87th of 360, with limits $1,383 a month | 129th of 360, with limits $81 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Only Ubicloud fits here: it rents Nvidia GPU VMs on request; GitLab's T4 runner is for CI jobs, and boat has no GPUs. | Can't run it | 93rd of 98, with limits $795 a month | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month Only GitLab fits here, with hosted macOS runners on Apple silicon in beta for Premium and Ultimate; Ubicloud and boat run Linux only. | 24th of 36, with limits $1,069 a month | Can't run it | Can't run it |
Key features
| Feature | GitLab.com hosted runners | Ubicloud | boat |
|---|---|---|---|
| Kind of product | CI runners: jobs run from a GitLab project's pipeline file | General cloud VMs you set up and run yourself, plus Postgres, Kubernetes and GitHub Actions runners | Sandbox API for agents: create, stop, fork and reach full VMs from your code |
| Isolation | New VM per job on Google Compute Engine, with passwordless sudo; Linux jobs run in a privileged Docker container | Full KVM guest (Cloud Hypervisor) with its own kernel and root over SSH | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts, with root and systemd |
| Session length | Up to 3 hours per job | No maximum documented; a VM runs until you stop or delete it | No cap on paid plans; you set the time to live |
| Disk between runs | The VM is deleted after each job; files carry over only through a shared cache (5 GB per archive) or artifacts | The disk stays while the VM exists; machine images of a stopped VM are made by hand | Disk persists, saved every minute and on stop |
| Stopping | Nothing to stop: the job ends and the VM is deleted | A stopped VM keeps its resources reserved and billing continues as if it were running | A stopped sandbox costs nothing and keeps its disk |
| Fork | No; every job starts from a fresh VM and a container image | Stop the VM, capture a machine image (single disk up to 40 GiB), then boot new VMs from it | Fork a running sandbox with its disk in one call |
| Docker and nested virtualization | Docker-in-Docker through privileged mode; nested virtualization not documented | Docker installs like on any Linux VM; nested virtualization not documented | Docker, root, systemd and /dev/kvm on every machine |
| Inbound access | None; inbound traffic is blocked and instance runners have no web terminal | SSH, free public IPv6, public IPv4 for $3 a month; for HTTPS the VM runs TLS itself | SSH, token-protected HTTPS URLs for up to 50 ports, raw TCP, own IP |
| Desktop and computer use | Headless; macOS runners do not support jobs that need UI interaction | None; you install a desktop and browser on the VM yourself | Linux desktop streamed at 60fps, Chromium, computer use API |
| Coding agents | Duo Agent Platform runs Claude Code, Codex, Amazon Q and Gemini agents from issues and merge requests, on Premium and Ultimate | None; you install and drive agents yourself, for example over SSH | Seven agents preinstalled, driven from outside with a prompt, steer and events API |
| Keeping API keys out of the machine | GitLab-managed credentials for its Claude and Codex agents only; other secrets enter the job as CI/CD variables | No credentials proxy; secrets live on the VM | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Operating systems and GPUs | Linux x64 and Arm64, Windows (beta), macOS on Apple silicon (beta), and a Linux runner with an NVIDIA T4 | Linux VMs, arm64 CI runners, Nvidia A100, B200 and RTX PRO 6000 VMs on request | Linux x64, no GPUs |
| Self-hosting | Open-source GitLab Runner (MIT) on your own machines, with no compute minutes used | The whole cloud is AGPL code you can run on your own servers | No, managed service only |
| Regions | US (Google Cloud us-east1 by default for Linux) | Germany, Finland and Virginia (US), plus GPUs in Istanbul | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | GitLab.com hosted runners | Ubicloud | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Not published | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | No | Yes | Yes |
| Pause/resume | No | No | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | No | Yes | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | No | No | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | Yes | No |
| Egress allowlist | No | No | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | No | No | No |
| GPU | Yes | Yes | No |
| Windows | Yes | No | No |
| Arm64 | Yes | Yes | No |
| Self-hosting | Yes | Yes | No |
| BYOC | No | Yes | No |
| Open source | Yes | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | No | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for GitLab.com hosted runners or for Ubicloud in the hpc-sandbox-benchmarks test. boat did 26.69 Node.js build-and-test runs per second there at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. On Ubicloud, results would also depend on the family: Standard VMs have dedicated CPU, while Burstable VMs get half of each vCPU.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. GitLab.com hosted runners and Ubicloud have no published run in this suite yet, so there is no like-for-like number to compare.
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.
| Scenario | GitLab.com hosted runners, a month | Ubicloud, a month | boat, 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 | $119 · Premium · with limits | $22 · Usage | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $805 · Premium · with limits | $91 · Usage | $26 · $20/mo |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $9,491 · Premium · with limits | $1,098 · Usage | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $2,658 · Premium · with limits | $156 · Usage | $200 · $100/mo × 2 seats |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $5,896 · Premium · with limits | $312 · Usage · with limits | $2,000 · $2000/mo · with limits |
GitLab.com hosted runners: Each job uses compute minutes equal to its run time times a cost factor, from 1 for small Linux up to 12 for the biggest machines. Plans include monthly minutes per group (Premium is $29 per user a month, billed yearly), and extra minutes cost $10 per 1,000, bought ahead of time.
Ubicloud: Ubicloud bills each VM per minute for as long as it exists, running or stopped, with no plan fee, and a public IPv4 adds $3 a month. The cheapest shapes are Burstable VMs with shared CPU.
Ubicloud: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
GitLab.com hosted runners fit none of the five scenarios as a sandbox: every job ends after 3 hours, nothing on the disk survives to the next job, and GitLab publishes no limit on how many runner VMs run at once. Ubicloud fits four of them, but a project starts at 32 vCPU and gets 256 after paying an invoice over $5, so 300 user sandboxes or 1,000 jobs at once need a raise from support. Its cheap burstable shape guarantees only half of each vCPU, so a busy burst gets throttled. boat's $2,000 plan queues starts above 90 a minute and allows fewer starts per day than the 1,000-job burst needs.
| Scenario | GitLab.com hosted runners | Ubicloud | boat |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
| None that bite | None that bite |
| 50 agents in parallel |
| None that bite | None that bite |
| Sandboxes for your users |
| None that bite | None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use GitLab.com hosted runners when
you build, test and deploy a GitLab project, especially for macOS, Windows or Arm64 builds, or when you want Claude Code or Codex working on your GitLab issues and merge requests.
- Native CI for GitLab projects. For building and testing a GitLab project, these runners work from the first pipeline with no extra service to wire up.
- macOS, Windows and Arm64 builds. Teams that build for Apple, Windows or Arm64 get a hosted runner for each; Ubicloud has no macOS or Windows machines.
- Agents on your issues and merge requests. On Premium and Ultimate, Claude Code and Codex can work on GitLab issues and merge requests from a mention.
Use Ubicloud when
you want plain Linux VMs that run as long as you like, GPU VMs, a US or EU region, an open source cloud you can run yourself, or VMs next to managed Postgres and Kubernetes.
- A machine that keeps running. A Ubicloud VM has no documented time limit and keeps its disk while it exists, so long work is not cut at 3 hours.
- GPUs and a whole cloud around the VM. Useful if agents need Nvidia GPU VMs, managed Postgres or Kubernetes next to them, or a region in the US or EU.
- Open source you can run yourself. Ubicloud's whole stack is AGPL code you can deploy on your own leased servers, not only the runner.
Where boat fits
If what you are really running is agents, neither choice is built for it: GitLab's runners end every job after 3 hours on a clean VM, and a Ubicloud VM is an empty Linux machine you set up yourself. boat gives each agent a full VM that keeps its disk, takes inbound traffic and comes with agents, a desktop and a credentials proxy ready.
A disk that stays, with free stops and fork
On GitLab each job starts clean and ends at 3 hours, so an agent reclones and reinstalls every time. A Ubicloud VM keeps its disk but bills while stopped, and copying it means stopping it to capture an image. boat snapshots every minute, stops for free and forks while running.
Reach it from outside
GitLab blocks all inbound traffic to hosted runners, so a preview needs a third-party tunnel inside the job. On Ubicloud you run TLS on the VM yourself. boat serves up to 50 ports on HTTPS URLs, raw TCP and a 60fps desktop.
Agents driven from outside, keys kept out
GitLab keeps keys out only for its managed Claude and Codex agents, and other tokens sit in CI/CD variables. On Ubicloud you install agents yourself and keys live on the VM. boat has seven agents preinstalled and a credentials proxy for any HTTPS API.
Use boat when each agent needs its own full VM that keeps its disk, stops for free, forks while running, takes inbound HTTPS, shows a desktop and keeps real API keys out of reach. Compare it one to one: boat vs GitLab.com hosted runners and boat vs Ubicloud.
Questions people ask
Is GitLab.com hosted runners cheaper than Ubicloud?
For machines that run long, Ubicloud costs far less: one agent that never stops comes to $805 a month on GitLab's runners against $91 on Ubicloud, and GitLab's runners do not fit that scenario anyway. boat comes to $26 for the same agent. For plain CI on a GitLab project, the minutes included in your GitLab plan can make it the cheaper choice.
Which is faster, GitLab runners or Ubicloud?
Neither has a comparable measurement in the hpc-sandbox-benchmarks CPU test, so there is no fair speed ratio. boat did 26.69 runs per second there at 4 vCPU / 8 GB. On Ubicloud, Standard VMs have dedicated CPU and Burstable VMs get half of each vCPU.
Can I run Docker on GitLab runners and on Ubicloud?
Yes on both. GitLab's Linux runners use privileged mode for Docker-in-Docker, and a Ubicloud VM gives you root, so Docker installs as on any Linux machine. boat has Docker, systemd and /dev/kvm on every sandbox.
Can a job or VM run longer than 3 hours?
Not on GitLab.com hosted runners: jobs time out after 3 hours whatever the project sets. A Ubicloud VM has no documented maximum and runs until you stop or delete it. A boat sandbox has no session cap on paid plans.
Do I pay for a stopped Ubicloud VM?
Yes. Ubicloud's docs say a stopped VM keeps its resources reserved and billing continues as if it were running, so to stop paying you delete it. GitLab bills only job time, and a stopped boat sandbox costs nothing and keeps its disk.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial
More comparisons
- boat vs GitLab.com hosted runners
- boat vs Ubicloud
- GitHub Actions vs GitLab.com hosted runners
- CircleCI vs GitLab.com hosted runners
- Blacksmith vs GitLab.com hosted runners
- Depot vs GitLab.com hosted runners
- WarpBuild vs GitLab.com hosted runners
- Buildkite vs GitLab.com hosted runners
- GitLab.com hosted runners vs Bitrise
- GitLab.com hosted runners vs Codemagic
- GitLab.com hosted runners vs RunsOn
- GitHub Actions vs Ubicloud