CI Runners for Bazel Builds¶
Speed up your Bazel builds using EngFlow CI runners that execute jobs in containers that keep a warm Bazel instance as well as a warm Bazel cache. When you opt into this feature, jobs from the supported CI providers can execute in containers running on EngFlow workers in your existing cluster. With warm Bazel, the initialization time for most jobs is significantly reduced because the container running the job has a cached file system and in-memory state from earlier CI jobs, even if that worker was newly instantiated.
We use official runner agents, and the workers in the cluster function like self-hosted, ephemeral CI runner machines. Using these workers provides efficiency gains from being co-located with your remote execution and caching instances.
EngFlow CI runners are currently available for the following CI providers:
What is a Bento?¶
As part of the initial set up to use EngFlow CI runners, you must create a Bento. A Bento describes everything needed to run a particular CI job: the Git repository to be cloned, the host architecture (x86-64 or arm64), and the container image that has all the tools (e.g. Bazel) required to execute the CI job. After creating a Bento, you can reference it from GitHub Actions or Buildkite job labels.
Example: Suppose you have two repositories hosted on GitHub:
MyCompany/devrunning jobs on x86-64 architectureMyCompany/prodrunning CI jobs on x86-64 and arm64 architectures.
To run CI jobs for these repositories on EngFlow CI runners, you would define Bentos containing the following information:
name="dev_x64", repo="github.com/MyCompany/dev", image="my.registry/x64/ci_dev@sha256:123(...)"name="prod_x64", repo="github.com/MyCompany/prod", image="my.registry/x64/ci_prod@sha256:456(...)"name="prod_arm64", repo="github.com/MyCompany/prod", image="my.registry/arm64/ci_prod@sha256:789(...)"
Speeding up builds using warm Bazel¶
When a CI job passes for the first time on an EngFlow CI runner, we create a snapshot of the container. This snapshot includes all changes made to the file system, as well as the process running on the CI runner, i.e., the Bazel server.
The next CI job can start from that snapshot, so the Bazel server is already there, with the source and build files already present.
We can reuse the snapshot any number of times on any worker machine.
How fast is warm Bazel?¶
Typical time to start a job: 30s median (includes booting a machine, restoring bazel, and starting the agent.)
This time includes a variable component that depends on the heap size of the bazel server (about 2 gbyte/s).
Typical time to fetch a change: 5s median (incremental git fetch)
Benefits of using EngFlow CI runners with warm Bazel¶
Performance¶
Lower latency: Since our CI runners are EngFlow worker VMs in the cluster, Bazel runs as close to the cluster as possible. This ensures minimal latency to the remote cache.
Reduce machine startup overhead: a single cloud VM can run multiple jobs, amortizing the overhead of acquiring and booting a VM.
Eliminate download overhead: the file system snapshot includes the source checkout and bazel caches. This makes all fetches and builds incremental.
Eliminate Bazel startup: the restored process snapshot includes a running Bazel server, with a primed analysis cache.
Reduce I/O overhead: filesystem data is fetched lazily. Start up time is independent of filesystem size.
Cost¶
Reduced compute costs: The runner pool auto-scales with the EngFlow cluster. Auto-scaling helps eliminate costs from idle VMs while also guaranteeing that runners will be available when there is a surge in queued jobs.
Eliminate network costs: the CI runner can bypass the public loadbalancer and contact the remote execution cluster directly.
Maintenance¶
Eliminate maintenance overhead: We provision and manage the runner fleet, freeing your team from maintaining self-hosted infrastructure.
Pull requests run warm, safely: Snapshots are taken only from submitted, reviewed code.
Pull requests results are isolated: PR runs all start from the same snapshot, so all presubmit results are isolated.
Snapshots stay fresh automatically: new snapshots are taken automatically at configurable frequency.
Bring your own image: public Debian-based images work out of the box, but you can bring your own image with preinstalled dependencies.
No extra authentication setup: Bazel in the CI job authenticates to your EngFlow cluster automatically.
Build results in one place: Every Bazel invocation in a CI job is linked in the Build and Test UI and tagged with the CI job, pipeline, and commit.
Stronger isolation when you need it: A Bento can run its jobs in a Firecracker microVM with its own kernel instead of a container.
Full builds for CI tools: CI jobs (eg. linters) can run off an existing snapshot, so they can be integrated into your Bazel build without concerns for CI latency.
Supported cloud providers¶
CI runners with warm Bazel are available on EngFlow clusters hosted on GCP and AWS.
Supported host platforms (CPU and OS)¶
We only support CI jobs running on arm64 and x64 Linux hosts.
Known limitations¶
As of November 2026:
- EngFlow tenants are not supported: CI jobs and their snapshots use the cluster's default tenant. The managed EngFlow service at https://managed.engflow.com serves many organizations through its own organization accounts; see Configure CI runners for Cursor Origin.
- For CI jobs that run Docker: we recommend using remote actions, or microVM based CI runners.