# Depot CI (https://depot.dev/docs/ci/overview)

Depot CI is a programmable CI system for engineers and agents. Workflows in Depot CI run entirely on Depot compute with built-in job visibility, debuggability, and control. GitHub Actions is the first syntax Depot CI supports: migrate your existing GitHub Actions workflows, and get fast, reliable runs on optimized infrastructure.

## Switching to Depot CI

Switching to Depot CI starts with one command: `depot ci migrate`.

The interactive wizard helps you install our GitHub App, discovers your GitHub Actions workflows, analyzes them for compatibility, and copies selected workflows and any local actions to a `.depot/` directory. Secrets and variables can then be automatically imported from GitHub in a separate step with `depot ci migrate secrets-and-vars`.

Your original `.github/` workflows continue running on GitHub in parallel until you're ready to switch over to Depot CI completely. For a step-by-step walkthrough, see the [quickstart](/docs/ci/quickstart).

## Feature summary

<table>
  <thead>
    <tr>
      <th scope="col" />

      <th scope="col" />
    </tr>
  </thead>

  {/* prettier-ignore */}

  <tbody>
    <tr>
      <td>
        <strong>
          GitHub Actions compatibility
        </strong>
      </td>

      <td>
        <ul>
          <li>
            Runs your existing GitHub Actions YAML workflows.
          </li>

          <li>
            Supports push, pull request, schedule, workflow dispatch, workflow call, workflow run, and merge group triggers.
          </li>
        </ul>
      </td>
    </tr>

    <tr>
      <td>
        <strong>
          Fast runs
        </strong>
      </td>

      <td>
        <ul>
          <li>
            Commit to running job in 2-3 seconds.
          </li>

          <li>
            Performance-tuned compute with pre-warmed sandboxes.
          </li>

          <li>
            Depot Cache is built in with no configuration required.
          </li>
        </ul>
      </td>
    </tr>

    <tr>
      <td>
        <strong>
          Custom images
        </strong>
      </td>

      <td>
        <ul>
          <li>
            Build a 

            [custom image](/docs/ci/how-to-guides/custom-images)

             with your dependencies and tooling pre-installed and use it from any Depot CI workflow.
          </li>

          <li>
            Jobs start with everything they need in the sandbox environment instead of rebuilding from scratch on every run.
          </li>
        </ul>
      </td>
    </tr>

    <tr>
      <td>
        <strong>
          Built-in debuggability
        </strong>
      </td>

      <td>
        <ul>
          <li>
            Connect to the sandbox running your job 

            [using SSH](/docs/ci/how-to-guides/debug-with-ssh)

            .
          </li>

          <li>
            CPU and memory metrics are captured for every job.
          </li>

          <li>
            Search logs across runs from the dashboard. Retrieve logs for runs via the CLI.
          </li>
        </ul>
      </td>
    </tr>

    <tr>
      <td>
        <strong>
          Local workflow runs
        </strong>
      </td>

      <td>
        <ul>
          <li>
            [Run a workflow against your local working tree](/docs/ci/how-to-guides/manage-workflow-runs#run-workflows-with-local-changes)

             without pushing to GitHub first.
          </li>

          <li>
            Uncommitted changes are automatically patched into the job after checkout.
          </li>

          <li>
            Pass 

            <code>--job</code>

             to run a subset of jobs.
          </li>
        </ul>
      </td>
    </tr>

    <tr>
      <td>
        <strong>
          CLI for engineers and agents
        </strong>
      </td>

      <td>
        <ul>
          <li>
            Trigger runs, fetch logs, and monitor job status from the 

            [CLI](/docs/cli/reference/depot-ci)

            .
          </li>

          <li>
            Works for engineers and agents: no GitHub event required to start a local run.
          </li>
        </ul>
      </td>
    </tr>

    <tr>
      <td>
        <strong>
          Workflows, logs, and metrics in the dashboard
        </strong>
      </td>

      <td>
        <ul>
          <li>
            View and manage all workflows from the 

            <a href="/orgs/_/workflows">Depot CI</a>

             page in your Depot dashboard.
          </li>

          <li>
            Retry failed jobs without re-running the entire workflow.
          </li>

          <li>
            See job-level metrics, step-level timing, and CPU and memory usage for your workflows.
          </li>
        </ul>
      </td>
    </tr>
  </tbody>
</table>

## How Depot CI works

Depot CI is built on top of Switchyard. Switchyard is a system that takes an arbitrary task and ensures it is executed across a fleet of compute.

Switchyard has two components:

* **Orchestrator**: Schedules tasks across the compute fleet. Handles dependencies between jobs and monitors progress.
* **Compute**: Executes workflow jobs. Receives a task from the orchestrator, provisions the compute resources needed (sandboxes), and executes the task.

Depot CI translates CI workflows and pipelines for the Switchyard orchestrator. The first syntax Depot CI supports is GitHub Actions YAML. Depot CI handles compatibility with how a standard GitHub Actions runner behaves, including environment variables, expressions, and action execution.

When you add a workflow file to `.depot/workflows/` in your repository and merge it to your default branch, Depot registers automatic triggers for that workflow. When a trigger fires, the orchestrator schedules jobs across the compute fleet and sends logs back to the Depot dashboard and CLI.

While Depot CI today runs GitHub Actions YAML, the system is programmable. Switchyard can give your own CI frontend direct API access to workflows, orchestration, and compute.

## Compatibility with GitHub Actions

Depot CI supports the most commonly used GitHub Actions syntax, including workflow-, job-, and step-level configuration, expressions, and all major action types.

For the full compatibility matrix, see [Depot CI compatibility with GitHub Actions](/docs/ci/compatibility).

## Pricing

Depot CI sandbox usage is tracked and billed by the second, with no one-minute minimum per run. The minutes included with each plan are based on the smallest sandbox size (2 CPUs/8 GB). The included plan minutes aren't a hard cap. Additional usage is billed automatically. For sandbox sizes and additional usage pricing, see [Depot CI sandboxes](#depot-ci-sandboxes).

|                      | Developer plan                                       | Startup plan                                          | Business plan |
| -------------------- | ---------------------------------------------------- | ----------------------------------------------------- | ------------- |
| **Plan cost**        | $20/month                                            | $200/month                                            | Custom        |
| **Depot CI minutes** | 2,000 included min/month<br />+ $0.0001/second after | 20,000 included min/month<br />+ $0.0001/second after | Custom        |
| **Cache**            | 25 GB included<br />+ $0.20/GB/month after           | 250 GB included<br />+ $0.20/GB/month after           | Custom        |

<DocsCTA buttonId="ci-docs-cta">
  <a href="/sign-up" className="text-radix-grass12">
    Try out Depot free for 7 days, no credit card required →
  </a>
</DocsCTA>

Plans also include [container build](/docs/container-builds/overview) minutes and [GitHub Actions runner](/docs/github-actions/overview) minutes. See [Pricing](/pricing) for more about plan features and costs.

## Depot CI sandboxes

Depot CI runs your workflows in x86\_64 sandboxes. Sandboxes can use from 2 CPUs/8 GB of memory up to 64 CPUs/256 GB of memory. The default sandbox image is based on Ubuntu 24.04.

Larger sandboxes consume the Depot CI minutes included in your plan faster and cost more per second for extra usage. For example, a 4-CPU sandbox uses 2 minutes for every 1 minute of running time.

Use a *Label* from the following table in the `runs-on` key of your workflow. For [custom images](/docs/ci/how-to-guides/custom-images), use a *Sandbox size* paired with a Depot Registry custom image URL in the `runs-on` key.

| Label                   | Sandbox size | CPUs | Memory | Per-second price | Plan minutes multiplier |
| :---------------------- | :----------- | :--- | :----- | :--------------- | :---------------------- |
| `depot-ubuntu-24.04`    | `2x8`        | 2    | 8 GB   | $0.0001          | 1x                      |
| `depot-ubuntu-24.04-4`  | `4x16`       | 4    | 16 GB  | $0.0002          | 2x                      |
| `depot-ubuntu-24.04-8`  | `8x32`       | 8    | 32 GB  | $0.0004          | 4x                      |
| `depot-ubuntu-24.04-16` | `16x64`      | 16   | 64 GB  | $0.0008          | 8x                      |
| `depot-ubuntu-24.04-32` | `32x128`     | 32   | 128 GB | $0.0016          | 16x                     |
| `depot-ubuntu-24.04-64` | `64x256`     | 64   | 256 GB | $0.0032          | 32x                     |

Depot CI doesn't provide sandboxes for Arm, macOS, or Windows. Labels for these runner types (as listed in [Depot GitHub Actions runner types](/docs/github-actions/runner-types)) aren't compatible with Depot CI.

## FAQ

<FAQSection>
  <FAQItem question="What is Depot CI?">
    Depot CI is a programmable CI system for engineers and agents. It's an entirely new CI engine, not a wrapper around
    GitHub Actions. Depot CI sits on top of Depot's own orchestrator and compute layer, built from the ground up for
    performance. GitHub Actions is the first workflow syntax Depot CI supports, so you can migrate your existing workflows
    from <code>.github/</code> to <code>.depot/</code> with a single command and run them on Depot's infrastructure
    without any YAML rewrites. Jobs start in 2-3 seconds, Depot Cache is built in with no configuration required, and
    everything has an API/CLI, so both engineers and agents can trigger runs, fetch logs, and monitor jobs without a
    GitHub event or the dashboard.
  </FAQItem>

  <FAQItem question="Do I need to change my workflow YAML to use Depot CI?">
    In most cases, no. Depot CI is designed to run your existing GitHub Actions YAML without modification. The
    <code>depot ci migrate</code> command copies your workflows and analyzes them for any compatibility issues before you
    commit.
  </FAQItem>

  <FAQItem question="Can I run Depot CI and GitHub Actions at the same time?">
    Yes. After migrating, your <code>.github/workflows/</code> files remain untouched and continue running on GitHub.
    Depot CI runs the copies in <code>.depot/workflows/</code> in parallel. This lets you test Depot CI without any risk
    to your existing workflows. Be mindful of workflows that write to external systems (deploys, artifact updates) since
    they will execute twice.
  </FAQItem>

  <FAQItem question="Can I run a workflow without pushing to GitHub?">
    Yes. The <code>depot ci run</code> command submits a local workflow file to Depot CI and applies any uncommitted
    changes automatically. You can also pass <code>--job</code> to run a subset of jobs and <code>--ssh-after-step</code>{' '}
    to open an interactive SSH debug session at a specific step.
  </FAQItem>
</FAQSection>

## Next steps

* [Quickstart for Depot CI](/docs/ci/quickstart)
* [Compatibility with GitHub Actions](/docs/ci/compatibility)
* [Manage secrets and variables](/docs/ci/how-to-guides/manage-secrets-and-variables)

## For AI Agents

The full site index is at [llms.txt](https://depot.dev/llms.txt). Append `.md` to any documentation, blog, changelog, or customer URL to fetch its markdown source directly.