Ephemeral CI agents keep builds clean and repeatable. The trade-off: every job starts with an empty Docker image store. So before your code compiles or a single test runs, the job downloads the same base images and the same test database it downloaded on the last run, and the run before that.
Nobody budgets for that wait, but every team pays for it. Every time a job runs docker pull for an image it already pulled on the last run, you pay for it three ways: in registry egress and consumption fees, in wall-clock time while jobs wait, and in builds that fail when a pull times out or hits a rate limit.
With Artifact Cache CLI 1.9.0, Develocity Artifact Cache now removes it. The images your jobs used last time are restored from Artifact Cache, close to your CI agents. Docker builds start with their base images in place, and containerized tests start with their service images already on the CI agent. Your Dockerfiles, test code and build scripts stay exactly as they are.
It's part of Develocity Universal Cache, so the same Artifact Cache that already serves your Maven, Gradle, npm and Python dependencies now serves your container images too: one cache to run, and one place to see what it does.
We turned it on in Develocity's own CI before releasing it:
- 97% of the Docker images our jobs used came from Artifact Cache.
- One pipeline run restores 21 GB of image layers that jobs would otherwise download from the registry.
- The slowest Dockerfile FROM steps (p90) dropped from 20 s to 1.3 s.
- Our CI agent image no longer carries 55 GB of baked-in Docker data.
- Images restored from Artifact Cache: the base images in your Dockerfiles' FROM steps, images your tests and jobs start with Docker Compose, docker run or a test library, and images pulled by digest.
- Not cached: images tagged latest or untagged, images a job builds itself, and the layers your Dockerfile's own steps build.
- Requirements: Artifact Cache CLI 1.9.0 or later, or the GitHub Action or Jenkins plugin that bundles it; Develocity 2026.3.0 and Edge 2.3.0 or later; Docker Engine 25 or later; and an Edge maximum artifact size above your largest image layer.
- Visibility: Gradle and Maven Build Scan data includes Artifact Cache metrics. With Artifact Cache CLI 1.10.0 and the Develocity Docker agent 0.9.1 or later, Docker Build Scan data includes Docker image restore values.
Registries charge for what they serve. Cloud registries bill data transfer out, Docker Hub meters pulls and rate-limits anonymous and free accounts, and a self-hosted registry needs capacity and bandwidth for every job that hits it. On ephemeral CI, each CI agent asks for the same layers it asked for on the last run, so that bill scales with your job count, not with what actually changed.
Job counts are climbing. AI coding assistants mean more commits, more pipeline runs and more containerized tests, and each run pulls the same bytes again. Without caching, the cost of moving images grows with build volume, not with the size of your team.
With Artifact Cache, each image comes from the registry once and from Artifact Cache after that. In our own CI, one pipeline run restores 21 GB of image layers from Artifact Cache that jobs would otherwise download from the registry. Distance doesn't change this: even with a registry right next to your CI agents, those bytes stay off its bill and out of its rate limits.
A pull is time a job spends before it does any work, and developers wait for it on every pipeline run. It's also unpredictable: a pull that is fast on a quiet morning can stall on a busy afternoon, and that slow tail is what makes feedback loops feel slow.
Restoring from Artifact Cache, close to your CI agents, takes most of that wait out. In our CI, the p90 of the slowest Dockerfile FROM steps dropped from 20 s to 1.3 s. The further your CI agents are from your registry, the more time each job gets back, and on CI platforms that bill by the minute, that time is money too.
Pulls fail. A registry under load times out, a rate limit returns 429 Too Many Requests, or a network blip drops a large layer halfway. Each failure turns into a red build that has nothing to do with the code being built, and a retry that pays the egress and the wait all over again. Someone has to notice it, rerun it and wait again.
Once Artifact Cache has seen an image, jobs restore it from Artifact Cache instead of the registry, so registry hiccups and rate limits stop reaching your builds for those images. Fewer unstable jobs means fewer retries, which compounds the savings on cost and time.
Most Dockerfiles start the same way: a FROM line naming a JDK, a distroless runtime or an Alpine base that rarely changes. On an ephemeral CI agent, that line means a fresh download on every build.
Artifact Cache restores those base images before the build starts, so the FROM step finds them already on the CI agent. Our heaviest image build restores 21 base images, 1 GB of layers, instead of pulling them on every run. Artifact Cache caches the images your builds start from, not the layers your Dockerfile builds itself; those still come from BuildKit's own cache.
It also simplifies how CI agents are provisioned. A common workaround for slow pulls is to pre-bake images into the CI agent's machine image; ours carried 55 GB of Docker data, whether a job needed it or not. With Artifact Cache, that workaround goes away: the machine image stays lean and each job restores only the images it actually uses.
Testing against a real Postgres, Kafka or identity provider in a container catches problems that mocks miss, whatever language your tests are written in. On ephemeral CI, it also means every test job downloads its databases and services before the first test can run.
Artifact Cache covers those images with no change to test code. Your tests can start containers with Docker Compose, docker run or a test library. Either way, the containers run on the CI agent, and the images they need are restored from Artifact Cache before the job begins.
In our own pipeline, the test database is the single most-used image: 76 of the 96 jobs that restore Docker images need only that one. Restoring it instead of pulling it takes a job from 9.2 s to 5.0 s. Multiplied across every test job, every pipeline run and every day, those seconds are where the hours go.
If you already use Artifact Cache, upgrade to Artifact Cache CLI 1.9.0. Docker caching is on by default wherever Docker runs on your CI agents, alongside the dependency caching you already have.
If you don't yet, Docker images join the rest of Develocity Universal Cache: dependencies, setup and task outputs, all served from Develocity Edge nodes next to your CI agents. It works independently of your CI platform: Jenkins, GitHub Actions, GitLab, TeamCity or any other. Universal Cache serves every pipeline instead of one cache per CI system.
Either way, your registry stays the system of record. Artifact Cache only takes over the repeat reads, so the registry stops serving the same bytes to every job.
A few things to check up front. Artifact Cache sees containers started on the CI agent's own Docker daemon, so services that GitHub Actions or Kubernetes pod-based CI agents start elsewhere still pull from the registry. If your jobs create a fresh buildx builder, add --enable-docker-builders so base images reach it too. And images tagged latest always pull, because their content can change, so pin the versions you depend on.
- For your Docker image builds: with the Develocity Docker agent on the build host, every image build publishes a Build Scan showing each build step's timing and cache usage, console output, failures, and the base images the build depends on. With Artifact Cache CLI 1.10.0 and Docker agent 0.9.1 or later, the Build Scan also carries Docker image restore values from Artifact Cache. Docker support isn't enabled by default; contact Develocity support to turn it on.
- For your Gradle and Maven builds: Build Scan data includes Artifact Cache metrics, through the Common Custom User Data plugins.
For more on how observability and caching fit together, read When AI code overloads CI, Universal Cache keeps builds fast and costs in control.
Request a guided trial, and we'll measure what your pipelines spend on image pulls and dependency downloads in egress, time and failed builds, and what Universal Cache removes. For the full numbers from our own pipeline, read How our CI replaced 55 GB of baked-in Docker images with Artifact Cache. For setup details, see the Artifact Cache documentation.
