Blacksmith, Depot, Namespace or Qovery: CI acceleration vs a build-and-deploy platform (2026)
Blacksmith, Depot and Namespace make GitHub Actions and Docker builds faster. Qovery builds your image, pushes it and deploys it to Kubernetes in your own cloud. A fair 2026 comparison with prices checked on each vendor's page, and when to use an accelerator, a platform, or both.
Blacksmith, Depot and Namespace are CI accelerators. They run your GitHub Actions jobs and Docker builds on faster machines with caches that stay warm between runs. None of them deploys the image to Kubernetes in your cloud or runs it afterwards.
Qovery is a build-and-deploy platform. It builds the image from Git, pushes it to a registry, deploys it to Kubernetes in your own AWS, GCP, Azure or Scaleway account (or any cluster), and gives each pull request its own preview environment. It does not run your test suite and it is not a GitHub Actions runner.
Pick an accelerator when the pain is slow or expensive test jobs. Blacksmith is the simplest swap, Depot is the broadest toolbox (its own CI engine, registry, cache, sandboxes, and a managed option in your AWS account), and Namespace suits teams that want runners plus devboxes for agents.
Pick Qovery when the pain is everything after the build: registry wiring, deploy scripts, environments, previews, rollback and access control for people and agents.
Many teams should use both. Keep the accelerator for tests. Let Qovery build the deploy image and ship it. Prices below were read on each vendor's own pricing page on 17 November 2026.
"GitHub Actions is slow at building our Docker images" is one of the most common complaints I hear from teams we talk to. The usual answer online is a list of runner vendors. That list is fine, but it mixes two different problems. One is "my CI jobs take too long". The other is "I have a whole pipeline from commit to running container, and the build is only the first step".
Blacksmith, Depot and Namespace solve the first problem well. Qovery, where I work, solves the second. I wrote this guide so you can tell which problem you have, what each vendor ships today, and what it costs, with every price linked to the vendor's own page. I also say where Qovery is the wrong pick.
We have not benchmarked Qovery against Blacksmith, Depot or Namespace, so every speed number below for those three is their own claim, and I attribute it. Our own numbers are measured against GitHub's standard runner, and I link the public benchmark.
How did we pick and judge the options?
We judged five options (GitHub-hosted runners as the baseline, Blacksmith, Depot, Namespace and Qovery) on six criteria that decide which tool fits which problem.
Where your CI jobs run. Is it a drop-in GitHub Actions runner, its own CI engine, or neither?
Docker image builds. Does it build container images, and does the layer cache persist between builds?
Registry. Does it store the image, or do you bring your own?
Runs in your cloud. Can the compute run inside your own cloud account, so code, secrets and images stay there?
Deploys and runs the app. Does it take the image to Kubernetes, run it, give each pull request an environment, and roll back?
Published prices. Can you price it from a public page today, without a sales call?
Agent sandboxes got a column too, because coding agents now open a growing share of pull requests and several vendors build for them. GitHub's Octoverse 2025 counted more than 1 million pull requests created by the Copilot coding agent between May and September 2025, on top of 43.2 million pull requests merged per month across GitHub (+23% year over year). More pull requests means more CI runs and more builds, whichever tool you pick.
Which tool does what? The comparison table
Blacksmith, Depot and Namespace all accelerate CI and builds, and Depot covers the most ground of the three. Only Qovery deploys the image to Kubernetes in your cloud and runs it with environments and per-PR previews.
Capability
GitHub-hosted runners
Blacksmith
Depot
Namespace
Qovery
Best for
The default, no extra vendor
Cheapest drop-in swap for GitHub Actions runners
Teams that want a full CI and build toolbox, optionally in their own AWS
Runners plus devboxes for agents, broad OS coverage
Build, push and deploy to Kubernetes in your own cloud, with previews
Pushes to a registry in your cloud account, then deploys from it
Own CI engine
GitHub Actions itself
No, runs your GitHub Actions jobs
Yes, Depot CI runs GitHub Actions YAML on Depot compute
No published CI engine, runners and Bazel remote execution
No, keep your CI for tests
Agent sandboxes
No
Testbox, early beta (Sandboxes announced as coming soon)
Yes, Depot Sandboxes and Managed Agents
Yes, Devboxes
No sandboxes; agents deploy through the MCP Server, Agent Skills and scoped API Policy Tokens
Runs in your cloud
Self-hosted runners, you operate them
No
Yes, Depot Managed on AWS for customers working with Depot
No published option
Yes, the app runs in your AWS, GCP, Azure or Scaleway account or your cluster
Deploys to Kubernetes
No, you write the deploy step
No
No
No
Yes
Runtime (runs the app afterwards)
No
No
No
No
Yes, on your Kubernetes cluster, with rollback
Preview environment per pull request
No, you build it
No
No
No
Yes, created on PR open, deleted on merge or close
Published prices (17 Nov 2026)
Linux 2-core x64 $0.006/min
Ubuntu x64 from $0.004/min, 3,000 free min/month
Developer $20/mo, Startup $200/mo, builds $0.04/min over plan
Team $100/mo, Business $250/mo, Linux 2 vCPU $0.002 to $0.003/min
Free plan, then Starter $299/mo, Growth $899/mo, Scale $2,999/mo
"Runs in your cloud" and "has a registry" are not unique to Qovery, since Depot has both and Namespace has a registry. The last three capability rows (deploy, runtime, previews) are empty for every accelerator, because none of them deploys.
Which problem do you have?
If your pull requests wait on slow test jobs, you have a CI speed problem, and an accelerator is the shortest path. If your pull requests wait on a deploy pipeline you maintain yourself, you have a delivery problem, and a faster runner will shave minutes off a pipeline you still have to own.
To tell which, open the last 20 runs of your main workflow and split the time into three buckets:
Tests and checks: lint, unit, integration. Accelerators shine here.
Image build and push:docker build, cache import and export, push to the registry. Accelerators and Qovery both do this.
Everything after the push: Helm or kubectl apply, waiting for rollout, preview environment scripts, cleanup jobs, secrets wiring. Only a deployment platform removes this bucket, because it removes the code you wrote to do it.
GitHub bills every job rounded up to the next whole minute (GitHub docs), and larger runners need the Team or Enterprise Cloud plan. When most of your time sits in the first bucket, keep reading the accelerator sections. When the third bucket is where your engineers lose their afternoons, the Qovery section is the relevant one.
If your workflows themselves are the problem (no cache, no concurrency groups, every job on every push), fix those first. Our 20 ways to speed up GitHub Actions covers that, and its tip 6 already summarises the faster-runner option in a paragraph.
Blacksmith: best for the cheapest one-line swap
Blacksmith is the right pick if you want your existing GitHub Actions workflows to run faster and cost less per minute with almost no change. It is the wrong pick if you need a registry, your own cloud account, or anything that deploys.
Blacksmith replaces GitHub-hosted runners with its own machines. The quickstart maps ubuntu-latest to a label such as blacksmith-2vcpu-ubuntu-2404, so the change is the runs-on: line.
What Blacksmith says about itself, on its homepage: "2x faster hardware" from "bare metal gaming CPUs with the highest single-core performance", "4x faster cache downloads" by co-locating cache artifacts in the same data center, and "40x faster Docker builds" by persisting Docker layers on NVMe drives across runs. These are vendor claims. One independent data point: Cal.com wrote that cache downloads were about twice as fast on Blacksmith (Cal.com).
Ubuntu x64 $0.004/min at 2 vCPU (larger runners cost more per minute), Ubuntu ARM from $0.0025/min, Windows x64 from $0.008/min, macOS M4 $0.08/min.
3,000 free minutes a month on all plans.
Docker layer caching and sticky disks at $0.50/GB-month each, static IPs at $100/IP/month.
Beyond runners, Blacksmith ships a console for GitHub Actions observability (job performance, log search, inline PR comments for failed tests). For coding agents it has Testbox, which syncs an agent's local changes to a Blacksmith runner and runs commands inside a real GitHub Actions job. Its docs call the CLI "agent-first" and say Testboxes are in early beta (Blacksmith docs).
Who should not pick Blacksmith: teams that need the build compute inside their own cloud account for compliance, or teams whose real bottleneck is the deploy pipeline. Blacksmith stops at the end of the CI job.
Depot: best for the broadest CI and build toolbox
Depot is the right pick if you want one vendor for fast runners, container builds, cache, a registry and agent sandboxes, with the option to run the build plane in your own AWS account. It is the wrong pick if you want the vendor to deploy and run your production app, which Depot does not do.
Depot has grown well past "fast Docker builds". Its homepage lists Depot CI, Depot Registry, Depot Code (Git-based source control "built for agents and engineers"), Depot Cache, container builds, GitHub Actions runners, and Managed Agents and Sandboxes. Depot CI is its own engine: the docs describe it as "an entirely new CI engine, not a wrapper around GitHub Actions", designed "to run your existing GitHub Actions YAML without modification" (Depot CI docs).
Depot's own claims: "40x faster container image builds", "10x faster builds with persistent, shared cache", and a "10x faster programmable CI engine". These are vendor numbers too. PostHog published a 12% to 13% shorter average job on Depot runners (Depot case study), which is a customer number on the vendor's site.
Business: custom, with dedicated infrastructure, GPU builds, static IPs, PrivateLink and SSO.
Over the plan: container builds $0.04/min (default 16-vCPU builder), GitHub Actions runners $0.006/min (2-vCPU Linux), sandbox compute $0.00005 per second per vCPU, storage $0.20/GB-month.
The own-cloud option is real. With Depot Managed on AWS, "the Depot data plane is deployed within an isolated sub-account of your AWS organization", and the build compute and cache stay in your account (Depot docs). The docs say it is for customers working with the Depot team, so expect a conversation rather than a self-serve toggle.
Who should not pick Depot: teams on GCP, Azure or Scaleway who need the build plane in their own account (the managed option documented today is AWS), and teams that want deployments, environments and runtime from the same vendor. You still need something to take Depot's image to your cluster.
Namespace: best for runners plus devboxes at agent scale
Namespace is the right pick if you want fast runners across Linux, Windows and macOS, Bazel remote execution, and devboxes where agents run untrusted code. It is the wrong pick if you need the compute in your own cloud account or a deploy step.
Namespace pitches itself as a "developer platform for agent scale" (homepage). Products: compute instances (Linux up to 64 vCPU and 512 GB, Windows up to 32 vCPU, macOS up to 16 vCPU), GitHub Actions runners, Bazel remote execution, Docker builds, a container registry, cache volumes and Devboxes, which it describes as cloud development environments for agents ("Sandboxes aren't enough. Your cloud agents need a Devbox").
Developer: pay as you go. Team: $100/month with 100,000 unit minutes and 1,000 Docker builds. Business: $250/month with 250,000 unit minutes and 2,500 Docker builds. Enterprise: custom.
Linux runners per minute, prepaid or overage: 2 vCPU $0.002 or $0.003, 4 vCPU $0.004 or $0.006, 8 vCPU $0.008 or $0.012. Windows costs 2x, macOS 10x.
Docker builds $0.05 per build on Developer, $10 per 1,000 builds over plan on Team and Business. Registry $0.20/GB-month.
Devbox Plus $250/month with 50,000 devbox minutes.
Per-build pricing for Docker is unusual, and it can work in your favour for long builds and against you for many tiny ones. Do the math on your own build mix.
Namespace runs on its own infrastructure, and I found no published option to run it in your own cloud account. It does not deploy or run your production app.
Who should not pick Namespace: teams whose security review requires source, secrets and images to stay in their own cloud account during the build, and teams looking for a deploy and runtime story.
Keep your fast runners. Let Qovery build and deploy.
Qovery builds your image, pushes it and deploys it to Kubernetes in your own AWS, GCP, Azure or Scaleway account, or your existing cluster, with a preview environment per pull request. Free plan, no credit card.
GitHub-hosted runners: the baseline you already pay for
GitHub-hosted runners are the right default when your jobs are short and your workflows are well cached. They are a weaker fit for heavy Docker builds without a warm cache.
Prices from GitHub's runner pricing reference: Linux 1-core $0.002/min, 2-core x64 $0.006/min, 2-core arm64 $0.005/min. x64 larger runners cost $0.012 (4-core), $0.022 (8-core), $0.042 (16-core), $0.082 (32-core) and $0.162 (64-core) a minute. Every job rounds up to a whole minute, larger runners need the Team or Enterprise Cloud plan, and they are not free for public repositories.
The baseline matters because every accelerator prices against it, and because it is the runner we measure Qovery against.
Qovery: best when the build is the start of a deploy
Qovery is the right pick when you want one path from a Git push to a running container on Kubernetes in your own cloud account, with environments, a preview per pull request and rollback. It is the wrong pick if all you want is cheaper or faster CI minutes, or a place to run your tests.
When you push, Qovery builds the image from your Dockerfile, pushes it to a registry in your cloud account and deploys it to Kubernetes in your own AWS, GCP, Azure or Scaleway account, or on any existing cluster (EKS, GKE, AKS, Kapsule, k3s, on-premise). You get environments, a preview environment per pull request that is deleted on merge or close, rollback, RBAC, audit logs, and API Policy Tokens to scope what an agent may do. By default, builds run on a pool of build workers on Qovery's side, in a separate Kubernetes cluster dedicated to builds. Building on your own cluster is an option. The app itself always runs in your account; Qovery is the control plane and never hosts it.
Build speed was our weak point, and I would rather say it than have you find it. In September, on our public benchmark (empty build, Node.js, Python FastAPI, React and Vite, Next.js standalone, PHP, and a roughly 2.5 GB image, timed from checkout to image in the registry), Qovery was 1.4x to 3.6x slower than GitHub's standard ubuntu-latest runner with Buildx. In October we moved builders from 8 GB to 16 GB of RAM, put builder nodes on local NVMe, switched images and cache to zstd, and stopped re-cloning when the image already exists. Across all customer builds, the median build went from about 3 minutes at the end of September to under 1.5 minutes in November, and the 95th percentile from about 11.5 to about 6 minutes.
Docker's buildx v0.39 (released 11 November, running on Qovery since 12 November) removed a wait of about 26 seconds per build. On the 13 November benchmark, Qovery matched GitHub Actions on typical apps and was faster on heavier builds: Python, Next.js and the large image finished in 0.86x to 0.90x of GitHub's time. The full story, including what is still slower, is in Making Qovery builds as fast as GitHub Actions, and then faster.
Since 12 November, a first group of customers sees per-step build timing in deployment logs and the Build Optimizer, which reads your Dockerfile, build logs and cache history and proposes a corrected Dockerfile. Persistent builder cache, faster CPUs and "build once, deploy many" are on our roadmap, not shipped.
On cost, Qovery is not cheaper per minute. Builds count toward your plan's deployment minutes, which also cover deploy time: 1,000 a month on Free (no overage billing), 3,000 on Starter at $299/month, 8,000 on Growth at $899/month and 30,000 on Scale at $2,999/month, with overage at $0.16 per minute (Qovery pricing). That is more per minute than any runner in this article. The cost case for Qovery is that you stop maintaining a separate CD pipeline, preview scripts and cleanup jobs, and you need fewer tools to get a commit running in your cloud.
Who should not pick Qovery: teams that only need faster test jobs, teams whose deploy story already works and only the CI bill hurts, and teams that do not run containers. For those, an accelerator from the sections above is the better buy.
Should we use both an accelerator and Qovery?
Yes, if your tests are slow and your deploy pipeline is a burden. Run tests on Blacksmith, Depot or Namespace runners, and let Qovery build the deploy image and ship it.
Here is the split I recommend to teams who ask:
Step
Where it runs
Why
Lint, unit and integration tests
Your accelerator's runners (or GitHub-hosted)
That is what they are built and priced for
Build the image you deploy
Qovery
The build runs next to the deploy, with per-step logs
Push to registry
Qovery, to a registry in your cloud account
No registry credentials in CI
Deploy and run
Qovery, on Kubernetes in your AWS, GCP, Azure or Scaleway account or your cluster
Environments, rollback, RBAC and audit logs come with it
Preview per pull request
Qovery
Created on PR open, deleted on merge or close
End-to-end tests against the preview URL
Your accelerator's runners
Tests stay in CI, against a real environment
In practice the workflow file gets shorter. Your test job keeps a runs-on: label from your accelerator, for example blacksmith-2vcpu-ubuntu-2404. The docker build, docker push and kubectl apply steps disappear, because Qovery reacts to the push and to the pull request through its own Git integration. You no longer write a deploy workflow or a cleanup workflow.
If your accelerator already builds a Docker image for your tests, you now build twice (once for tests, once to deploy). That is fine when the test image is small. When it is not, run the tests inside the preview environment Qovery deployed, or point integration tests at the preview URL, so one build serves both.
Depot's registry and Depot Managed on AWS overlap with parts of what Qovery does, and the two can sit side by side. Nothing in this setup asks you to drop a vendor you are happy with.
Is Depot or Blacksmith enough, or do we still need a deployment platform?
Depot or Blacksmith is enough if you already have a deploy path you trust, such as Argo CD watching a Git repo, a managed PaaS, or a Helm step your team is happy to maintain. You still need a deployment platform, or something you build, when nobody owns the path from image to running environment.
Signs you need more than an accelerator:
Your CI workflow has more deploy steps than test steps.
Preview environments live in a pile of Terraform and shell scripts one person understands.
Rollback means re-running an old workflow and hoping.
Coding agents open pull requests nobody can try without pulling the branch locally.
Your security team asks who can deploy what, and the honest answer is "anyone with the CI secrets".
Which platforms build from Git, push to a registry and deploy to Kubernetes in one step?
Qovery does all three from a Git push, into your own cloud account. Other ways to get there exist, with more assembly: GitHub Actions plus Argo CD, GitLab CI with its registry and a Kubernetes deploy job, or Argo CD Image Updater after any CI that pushes an image.
Option
Build from Git
Registry
Deploy to Kubernetes
Preview per PR
What you maintain
Qovery
Yes
Yes, in your cloud account
Yes, your cluster in your account
Yes
Dockerfile and Qovery config (Console, Terraform provider or API)
GitHub Actions + Argo CD
Yes (Actions)
GHCR or your own
Yes (Argo CD)
With ApplicationSets and extra setup
Workflows, manifests, Argo CD itself
Accelerator + Argo CD
Yes (fast runners)
Depot or Namespace registry, or your own
Yes (Argo CD)
With ApplicationSets and extra setup
Workflows, manifests, Argo CD itself
GitLab CI + Kubernetes job
Yes
GitLab registry
Yes, via your deploy job
With review apps and extra setup
Pipelines, manifests, cluster access
The Argo CD rows are good setups. They mean your team owns more moving parts, which is the right trade for a team with platform engineers and the wrong one for a team without.
How do I try this from Claude Code or Cursor?
Install the Qovery Agent Skills and your coding agent can deploy a repository to Kubernetes in your own cloud account through the Qovery API, while your existing CI keeps running the tests. These are the commands, in order.
BASH|1. Agent Skills, global: Claude Code, Cursor, Codex, OpenCode, Gemini CLI and others
curl -fsSL https://skill.qovery.com/install.sh | bash
# 2. Or scoped to the current project
curl -fsSL https://skill.qovery.com/install.sh | bash -s -- --project
# 3. MCP Server for Claude Code, OAuth, read-only by default
claude mcp add --transport http qovery https://mcp.qovery.com/mcp --callback-port 4242
# 4. Write access, only when you explicitly want it (also needs write access enabled in the Qovery Console)
claude mcp add --transport http qovery "https://mcp.qovery.com/mcp?read_write=true" --callback-port 4242
Your agent asks you to approve each install command, and the MCP Server opens an OAuth login in your browser. Then ask in plain language: "deploy this app to my AWS account with Qovery". The skills deploy (qovery-onboard, qovery-deploy, qovery-preview, qovery-speedup among them); the MCP Server operates what already exists. Start with the AI agent quickstart or the Claude Code integration.
Frequently asked questions
Blacksmith vs Depot vs Namespace: which GitHub Actions runner accelerator should we pick?
Pick Blacksmith for the simplest swap and the lowest published Ubuntu x64 entry price ($0.004/min at 2 vCPU, 3,000 free minutes a month). Pick Depot if you want its own CI engine, registry, cache, sandboxes and an option to run in your AWS account. Pick Namespace for runners across Linux, Windows and macOS plus devboxes for agents. Test the two closest fits on your own slowest workflow, because their speed figures are vendor claims.
Is Depot or Blacksmith enough, or do we still need a deployment platform?
They are enough if you already have a deploy path you trust, such as Argo CD or a well-kept Helm step. Neither deploys the image to Kubernetes in your cloud or runs it, so without a deploy path you still need a platform like Qovery or something you build and maintain yourself. Many teams keep the accelerator for tests and use Qovery for build and deploy.
GitHub Actions is slow at building our Docker images. What are our options?
First fix the workflow: layer cache with Buildx, a Dockerfile that installs dependencies before copying source, and concurrency groups. Then you can move builds to an accelerator with persistent layer caches (Blacksmith, Depot, Namespace), or move the deploy build to a platform that builds and deploys in one step, like Qovery. Measure your own builds before and after, since every vendor publishes its own speed figures.
Which platforms build from Git, push to a registry and deploy to Kubernetes in one step?
Qovery builds from a Git push, pushes to a registry in your cloud account and deploys to Kubernetes in your own AWS, GCP, Azure or Scaleway account or your existing cluster, with a preview environment per pull request. GitHub Actions or GitLab CI combined with Argo CD reach the same result with more pieces for your team to maintain.
Is Qovery faster than Blacksmith, Depot or Namespace?
We don't know, because we have not benchmarked against them, and I won't claim it. Our public benchmark compares Qovery with GitHub's standard runner: on 13 November 2026 Qovery matched it on typical apps and finished Python, Next.js and large-image builds in 0.86x to 0.90x of GitHub's time.
Is Qovery cheaper per build minute than these runners?
No. Qovery's overage is $0.16 per deployment minute, which covers build and deploy time, and that is more per minute than GitHub-hosted runners or any accelerator here. The saving, when there is one, comes from dropping a separate CD pipeline, preview scripts and the time your team spends maintaining them.
Alessandro leads product at Qovery. He drives the changelog, roadmap, and product strategy - turning customer feedback into platform capabilities.
Next step
Keep your fast runners. Let Qovery build and deploy.
Qovery builds your image, pushes it and deploys it to Kubernetes in your own AWS, GCP, Azure or Scaleway account, or your existing cluster, with a preview environment per pull request. Free plan, no credit card.