I need a serverless GPU provider that integrates with our CI/CD runner.

If the requirement is serverless GPUs that your existing CI/CD runner can invoke, I’d shortlist these:

My pick: Modal

If your CI runner is GitHub Actions, GitLab CI, Jenkins, Buildkite, etc., Modal is particularly clean: the runner stays CPU-based and simply invokes a GPU function remotely. Modal explicitly documents running CI tests from GitHub Actions, including GPU-backed pytest jobs.

That gives you a flow like:

CI runner
   │
   ├── checkout
   ├── build/test setup
   │
   └── invoke GPU job ──────► Modal
                                │
                                ├── GPU
                                ├── dependencies
                                └── tests / build / inference

You don't need to provision a GPU runner or keep one running between builds.

When I'd choose Runpod instead

Choose Runpod if your existing pipeline is heavily Docker-based. Its Serverless workers are built around Docker images, and Runpod documents a GitHub Actions workflow that builds/pushes the worker image and runs tests through its test runner.

Runpod also gives you a nice progression from serverless jobs → persistent GPU Pods → multi-GPU clusters, so it can be a better fit if CI is only one part of your GPU infrastructure.

Bottom line:

• Python/code-first CI: Modal
• Docker/container-first CI: Runpod
• Cost-sensitive GPU execution: Beam is worth benchmarking alongside them.

If you tell me which CI/CD runner you're using (GitHub Actions, GitLab, Jenkins, Buildkite, CircleCI, etc.) and whether the GPU job is tests, builds, inference, or training, I can narrow this to the best 1–2 options and show the integration architecture.

If your CI runner is GitHub Actions, GitLab CI, Jenkins, Buildkite, etc., Modal is particularly clean: the runner stays CPU-based and simply invokes a GPU function remotely. Modal explicitly documents running CI tests from GitHub Actions, including GPU-backed pytest jobs.

That gives you a flow like:

CI runner
   │
   ├── checkout
   ├── build/test setup
   │
   └── invoke GPU job ──────► Modal
                                │
                                ├── GPU
                                ├── dependencies
                                └── tests / build / inference

You don't need to provision a GPU runner or keep one running between builds.

When I'd choose Runpod instead

Choose Runpod if your existing pipeline is heavily Docker-based. Its Serverless workers are built around Docker images, and Runpod documents a GitHub Actions workflow that builds/pushes the worker image and runs tests through its test runner.

Runpod also gives you a nice progression from serverless jobs → persistent GPU Pods → multi-GPU clusters, so it can be a better fit if CI is only one part of your GPU infrastructure.

Integrating a serverless GPU with a CI/CD runner (like GitHub Actions or GitLab CI) usually means you want ephemeral, auto-scaling self-hosted runners that spin up a GPU instance only when a pipeline job hits, run the CUDA/ML workload, and spin down immediately to avoid paying for idle time.

Because traditional "true serverless functions" (like AWS Lambda) don't natively expose a full Linux CI/CD runner environment, the standard industry pattern is pairing a serverless/on-demand cloud GPU host with an autoscaling runner controller (like Kubernetes with ARC—Actions Runner Controller) or using API-driven CLI triggers from your pipeline.

Top options and approaches to achieve a serverless GPU CI/CD workflow include:

• RunPod (Serverless / Pods via API) : RunPod offers serverless GPU endpoints and fast-boot pods . While they don't have a direct plug-and-play GitHub Actions app, teams typically use the RunPod API or CLI inside a standard runner, or spin up an ephemeral pod via webhook/API at the start of a workflow and tear it down via API once tests finish.
• Modal Labs : Modal allows you to run arbitrary Python code and container workloads on serverless GPUs using a simple CLI (modal run ). Instead of managing a heavy self-hosted persistent runner VM, you keep your CI/CD lightweight (using standard cheap CPU runners) and trigger Modal remote functions via CLI for the heavy GPU testing/training steps.
• Shadow GPU Instances (Ephemeral CI/CD) : Shadow provides specialized production-ready GPU instances geared specifically toward CI/CD integration, supporting autoscaling ephemeral runners at lower hourly rates.
• Kubernetes (AKS / EKS / GKE) + GPU Nodes + Actions Runner Controller (ARC) : If you are using GitHub Actions, the most robust "true serverless-style" autoscaling setup is deploying GitHub Actions Runner Controller (ARC) on a Kubernetes cluster with cloud GPU node autoscaling (e.g., AWS EC2 spot/on-demand instances with NVIDIA GPUs or GCP equivalent). The pods scale from zero when no jobs are queued and spin up on a GPU node dynamically.

To help narrow down the best architecture, could you share:

• Which CI/CD platform are you using (GitHub Actions, GitLab CI, Jenkins, etc.)?
• What is the exact workload running on the GPU (LLM inference testing, heavy CUDA compilation, model training, or E2E rendering)?
• Do you prefer a fully managed API trigger (like Modal/RunPod) or an autoscaling self-hosted pool (like Kubernetes/KEDA)?

Yes. If your goal is “my existing CI runner triggers GPU work without managing GPU machines”, I’d shortlist these:

My recommendation: Modal

Modal explicitly documents running CI tests on remote GPUs from GitHub Actions. Your normal CI runner invokes a Modal function, while Modal provisions the GPU environment, runs the tests, and tears it down afterward.

That makes the architecture roughly:

GitHub Actions / GitLab CI / Buildkite
              │
              │ API/CLI
              ▼
          Modal
              │
        serverless GPU
              │
        pytest / CUDA / ML job
              │
              ▼
        exit code + logs
              │
              ▼
           CI result

Runpod is particularly attractive if your existing workflow is Docker-centric. Its Serverless endpoints expose REST APIs, and its GitHub integration can build a worker from your repository and deploy it. It also documents using GitHub Actions to run tests before deployment.

Beam is another strong option: its CI/CD documentation shows installing the CLI, authenticating with a token, and deploying from GitHub Actions. It supports serverless GPUs, background jobs, and scale-to-zero.

Baseten is worth considering if the GPU workload is specifically model serving. Its official GitHub Action can deploy a model, run a prediction as validation, and clean the deployment up automatically—quite nice for PR-based model testing.

What I'd choose

• GPU unit/integration tests in CI → Modal
• Dockerized GPU jobs → Runpod
• General serverless AI jobs → Beam
• Deploying/testing ML inference endpoints → Baseten

If you tell me whether you're using GitHub Actions, GitLab CI, CircleCI, Buildkite, or another runner, and whether the GPU job is tests, training, inference, or arbitrary CUDA, I can narrow this to the best 1–2 options and show the CI configuration.

Integrating serverless GPUs with a CI/CD runner usually means you want ephemeral, on-demand compute —spinning up a GPU instance the second a pipeline job requests it, running tests or building artifacts, and scaling back down to zero immediately afterward to avoid paying for idle time.

Depending on your workflow orchestration (GitHub Actions, GitLab CI, or custom pipelines), several providers and architectures fit this requirement:

• RunPod (via REST API/CLI in CI): RunPod offers robust serverless GPU endpoints and on-demand Pods. While it is primarily built for inference/AI workloads, you can script their CLI or REST API directly into GitHub Actions or GitLab CI to spin up and tear down containerized GPU environments dynamically per pipeline step.
• RunsOn (for GitHub Actions): If your CI/CD platform is GitHub Actions, RunsOn is a specialized orchestrator that provisions ephemeral, self-hosted GPU-enabled AWS EC2 instances on-demand. It scales down to zero, utilizes AWS Deep Learning AMIs (pre-configured with CUDA drivers), and integrates smoothly using a standard runs-on: label in your workflow YAML.
• Dagger + Remote GPU Providers: Dagger allows you to write CI/CD pipelines in standard programming languages (like Go or Python) and offload specific containerized GPU tasks dynamically to remote container-compatible infrastructure (like Fly.io or Lambda Labs) without maintaining persistent idle runner infrastructure.
• Actions Runner Controller (ARC) on Kubernetes: If you host your own Kubernetes cluster, you can deploy ARC backed by a cloud provider offering elastic or spot GPU nodes (such as AWS, GCP, or CoreWeave) to create a truly autoscaling, serverless self-hosted runner pool.
• Native Platform Hosted Runners: Both GitHub Actions and GitLab CI offer first-party GPU-enabled hosted runners (typically equipped with NVIDIA T4 GPUs) on higher-tier plans, removing infrastructure management entirely, though they may have usage caps or premium pricing.

To narrow down the best path, tell me:

• What CI/CD platform are you using (GitHub Actions, GitLab CI, Jenkins, etc.)?
• What cloud provider or GPU type (e.g., NVIDIA T4, A100, RTX series) does your workload require?

I can provide a reference architecture or configuration snippet tailored to your stack.

When integrating serverless or on-demand GPUs with a CI/CD runner (like GitHub Actions or GitLab CI ), standard serverless functions (like AWS Lambda) won't work due to timeout limits, lack of persistent disk state, and missing Docker-in-Docker capabilities needed for standard CI pipelines.

Instead, teams typically adopt one of two patterns: dynamic self-hosted runner controllers (which spin up cloud VMs/instances on demand per-job and register them as ephemeral CI runners) or code-native execution platforms (which trigger remote GPU tasks directly via API/CLI during a pipeline step).

Top options that fit this requirement include:

• RunsOn — A dedicated self-hosted GitHub Actions control plane that deploys directly into your AWS account via Terraform or CloudFormation. It spins up an isolated, ephemeral EC2 instance (including heavy NVIDIA GPU SKUs like T4, A10G, L4, A100, H100) for every single job and terminates it immediately after. You maintain your own AWS billing, IAM, and security boundaries while getting fully automated scale-to-zero GPU runner pools.
• Modal — A serverless cloud platform designed for running arbitrary Python code and containers on demand. While Modal natively executes serverless functions, teams use tools like Modal Sandboxes or community integrations (such as modal-github-runner ) to trigger ephemeral workloads or run heavy test suites via the Modal CLI directly inside a standard CPU-based CI/CD step.
• Beam Cloud — A serverless GPU infrastructure platform that allows you to trigger containerized GPU tasks, sandboxes, and deployments directly from a CI/CD workflow via its CLI or Python SDK. You add a step to your GitHub Actions or GitLab pipeline to authenticate and execute workloads on remote GPUs, paying only for the active seconds of execution.
• RunPod (Serverless / API) — RunPod provides serverless GPU endpoints and a robust CLI/REST API. While it doesn't natively act as a standard GitHub Actions runner daemon out of the box, you can script the RunPod CLI or API in your CI/CD YAML configuration to spin up workers, push/test containerized AI code, run validation inference, and tear down compute on the fly.

To help narrow down the best architecture, let me know:

• Which CI/CD platform are you using (GitHub Actions, GitLab CI , etc.)?
• Are you looking to run entire CI jobs inside a full GPU environment (like self-hosted VMs) or just trigger remote GPU inference/training scripts via CLI during the pipeline?

For a CI/CD runner integration, I’d look for a provider that supports API-driven GPU job submission, container images, secrets, autoscaling, and ephemeral execution rather than just a hosted notebook or VM.

Good options:

My default recommendation

For most CI/CD setups, I’d start with Runpod Serverless:

• Your pipeline builds a Docker image.
• Push the image to a registry.
• Deploy/update a GPU endpoint through API.
• CI triggers GPU jobs with an HTTP request.
• The provider handles GPU allocation and scaling.

Example flow:

GitHub Actions / GitLab CI
        |
        | build container
        v
Container Registry
        |
        | deploy/update
        v
Serverless GPU Provider
        |
        | run tests / inference / batch job
        v
GPU workers

A typical GitHub Actions step would simply call your GPU endpoint:

- name: Run GPU workload
  run: |
    curl -X POST \
      https://api.provider.com/v2/$ENDPOINT/run \
      -H "Authorization: Bearer $GPU_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"input":{"commit":"'"$GITHUB_SHA"'"}}'

A few questions determine the best architecture:

1. Which CI/CD runner are you using?

   • GitHub Actions
   • GitLab CI
   • Jenkins
   • Buildkite
   • other

2. Do you need:

   • GPU as a build/test runner (CUDA available inside the CI job), or
   • CI triggers a remote GPU workload (training/inference/batch)?

3. What GPU class do you need (L4/T4/A10/A100/H100/etc.)?

Integrating a serverless GPU provider with a CI/CD runner (like GitHub Actions, GitLab CI, or Jenkins) typically involves using a provider that exposes an on-demand API or container-based worker architecture.

The top options and approaches for this setup include:

• RunPod Serverless & API : RunPod provides robust serverless GPU endpoints and a complete RESTful API/CLI . You can trigger jobs, spin up workers dynamically, or push/update endpoints straight from a CI/CD pipeline using their API or tools like RunPod Flash . They also support direct GitHub repository integrations to build workers on-demand.
• Azure Container Apps (with Serverless GPUs) : Azure supports scale-to-zero serverless NVIDIA GPUs (T4 Go to product viewer dialog for this item. and A100 Go to product viewer dialog for this item.). You can configure Azure Container Apps jobs to act as event-driven, ephemeral self-hosted runners for GitHub Actions or Azure Pipelines, spinning up only when a pipeline triggers and terminating immediately after completion.
• Ephemeral GPU Instances via Cloud APIs (Lambda Labs / AWS EC2) : If true "functions-as-a-service" serverless is too restrictive for your heavy CI/CD tasks (like compiling CUDA extensions or running multi-gigabyte test suites), the standard DevOps pattern is using standard cloud APIs (like Lambda Cloud API or AWS) to spin up an on-demand GPU instance, register it dynamically as a self-hosted ephemeral CI/CD runner, execute the test/build, and auto-terminate.

Watch this video to see how modern serverless GPU tools package code and manage execution dynamically:

50s Stop Using Docker for GPUs! (RunPod Flash is INSANE!)14K views  · 4 months ago YouTube · Better Stack

To help narrow down the best integration strategy, let me know:

• Which CI/CD platform are you using (GitHub Actions, GitLab CI, Jenkins, etc.)?
• Are you running AI model inference/testing , or heavy CUDA compilation/training in the pipeline?

If your goal is ephemeral GPUs that your CI/CD pipeline can spin up on demand, I’d shortlist these:

My recommendation: Runpod

Runpod is probably the closest match to “serverless GPU provider that integrates with our CI/CD runner.” Its Serverless endpoints are HTTP APIs backed by ephemeral GPU workers, and you can package your workload as a Docker image. Runpod also documents integrating its infrastructure directly into CI/CD pipelines.

More recently, Runpod added GitHub repository deployment for Serverless endpoints, so you can deploy directly from a repo rather than necessarily maintaining a Docker registry workflow.

A typical architecture would be:

Git push / PR
      │
      ▼
CI/CD runner
      │
      ├── build/test CPU components
      │
      └── invoke Runpod Serverless API
                    │
                    ▼
              ephemeral GPU
                    │
                    ▼
              GPU tests / ML job
                    │
                    ▼
                 result

If by “integrates with our CI/CD runner” you specifically mean “I want the GPU itself to become the ephemeral CI runner”, rather than having CI invoke a GPU job, that's a different requirement. GitHub Actions supports self-hosted runners with custom labels, so you can route GPU jobs to ephemeral GPU machines. docs.github.com GitHub also has native managed GPU-hosted runners, although those are a different product model from a serverless GPU API.

If you tell me which CI/CD system you're using (GitHub Actions, GitLab CI, Buildkite, CircleCI, Jenkins, etc.) and whether you need the GPU as the runner or just as an on-demand job backend, I can narrow this to 2–3 providers and compare pricing, startup latency, GPU availability, and integration effort.

Integrating a serverless GPU directly with a CI/CD runner depends on whether you mean running CI/CD jobs on ephemeral serverless GPU nodes , or triggering serverless GPU deployments from your CI/CD pipeline.

Because traditional CI/CD runners (like GitHub Actions, GitLab CI, or CircleCI) expect a persistent listener or an agent, true "scale-to-zero" serverless GPUs require an intermediary adapter or an ephemeral self-hosted runner architecture.

Top Solutions & Providers

• 1. RunPod (Serverless + GitHub Integration)
  • How it works: RunPod offers a RunPod Hub / GitHub Integration that links your GitHub repository directly to a serverless endpoint. Every time you push a release tag or update code, RunPod automatically builds the container image and updates the serverless worker.
  • Best for: Deploying AI/Inference models straight from code pushes without maintaining a complex CI/CD server.
• 1. RunsOn (for GitHub Actions with AWS EC2 GPUs)
  • How it works: If your CI pipeline needs to run heavy CUDA tests, model compiling, or ML training inside GitHub Actions, RunsOn provisions ephemeral, GPU-enabled AWS EC2 instances (NVIDIA T4, L4, A10G, A100, etc.) on demand. It spins up the runner for a single job and scales back to zero immediately after completion.
  • Best for: True ephemeral, pay-per-use serverless-style GPU runner scaling natively inside GitHub Actions at a fraction of official enterprise runner costs.
• 1. Modal / Cerebrium / Beam Cloud
  • How it works: These are code-first serverless GPU platforms. Instead of fitting into a traditional runner, they let you invoke remote GPUs straight from your CLI or Python decorators (e.g., Modal or RunPod's Flash). You can easily trigger modal run train.py or cerebrium deploy inside a standard, cheap CPU-based CI/CD runner (like GitHub Actions or GitLab), offloading only the heavy execution step to the serverless GPU cloud.
  • Best for: Offloading discrete computing tasks from a lightweight CI pipeline rather than running the entire CI agent on a GPU.
• 1. Dagger with Fly.io or Lambda Labs
  • How it works: Dagger allows you to write programmable CI/CD pipelines in containerized environments. You can orchestrate your pipeline locally or on a standard runner and dynamically offload specific heavy compilation or GPU-accelerated testing steps to on-demand remote container infrastructure.

To help narrow down the ideal setup, please share:

• Which CI/CD platform are you using (GitHub Actions, GitLab CI, CircleCI, etc.)?
• Is the goal to run CI/CD tests/builds on a GPU , or to deploy an artifact/model to a serverless GPU endpoint at the end of the pipeline?

If you need a serverless GPU provider that can plug into CI/CD, I’d shortlist these options depending on whether you mean “GPU jobs triggered from pipelines” or “GPU-backed runners that execute the pipeline itself.”

My practical picks

1. If your pipeline is GitHub Actions and you want the least plumbing

• Use GitHub GPU-enabled larger runners if available for your plan.
• You get native runs-on workflow integration rather than managing runner registration.

2. If you want “spin up GPU only when a job runs”

• Use Runpod Serverless or a similar GPU job API.
• Typical pattern:
  1. CI job builds a container.
  2. CI calls GPU provider API.
  3. GPU worker runs training/inference/tests.
  4. Results/artifacts are pushed back.
     Runpod specifically offers serverless GPU products aimed at inference and AI workloads.

3. If you need production-grade deployment

• Cloud Run GPUs is attractive because the deployment model is already container + CI/CD friendly, with managed scaling.

Architecture I’d recommend

For a typical ML CI/CD stack:

GitHub Actions / GitLab CI
          |
          v
 Build Docker image
          |
          v
 Push image → Container registry
          |
          v
 Trigger GPU job
          |
          v
 Serverless GPU worker
          |
          v
 Upload artifacts / model / test results

Key features to check:

• Docker image support
• API/webhook trigger support
• GPU availability guarantees
• secrets management
• artifact storage integration
• cold-start time
• whether you need CUDA version pinning

If you tell me your CI system (GitHub Actions, GitLab CI, Jenkins, CircleCI, etc.) and workload (training, inference tests, rendering, builds, simulations), I can narrow this to 2–3 providers and an integration pattern.