From the user [Settings](/settings) page you can do the following:
* Sign out of your Depot account
* Update your profile name
* Create [user access tokens](/docs/cli/authentication#user-access-tokens) to authenticate for local development
* Add public SSH keys for authentication
You can't change the email address for your Depot account. To delete an account, send a request to [help@depot.dev](mailto:help@depot.dev).
## Organizations
Every action you take in Depot is within the context of an organization. An organization typically represents a single company or team. Depot bills at the organization level, consolidating all usage across products into a single invoice.
You can view all of your builds, runners, usage, and billing per organization in your Depot dashboard. Configure organization-level settings in the organization [Settings](/orgs/_/settings) page.
### Create an organization
When you sign up for Depot, we either prompt you to create an organization, or you automatically join the organization you were invited to.
To create a new organization or request to join an organization:
1. Log in to your [Depot dashboard](/orgs).
2. Click the organization name at the top of the page.
3. Go to **Switch organization** and select **Create a new organization**.
### Switch organizations in the Depot dashboard
1. Log in to your [Depot dashboard](/orgs).
2. Click the organization name at the top of the page.
3. Go to **Switch organization** and select another organization from the list.
### Organization access roles
Organizations have role-based access. When you create an organization, you have the owner role and permissions.
| Role | Permissions |
| ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Owner | Manage all organization settings, such as billing, payments, SSO (if purchased), tokens, and GitHub connections. Manage members, including invitations, roles, and removal. Manage projects, builds, and runners. Access usage and analytics. |
| Member | Manage projects, builds, runners. Access usage and analytics. |
### Invite and manage organization members
If you have a Startup or Business plan, you can invite users to join an organization.
1. Log in to your [Depot dashboard](/orgs).
2. Under **Organization**, click [Settings](/orgs/_/settings).
3. From the **Members** section of the **Settings** page you can:
* View members and change their role.
* View or remove pending invites.
* Invite new members using either their existing Depot account email or the email they'll use to sign up for Depot.
When you invite someone to join your organization, they receive an invitation email with an **Accept invite** link. If the user doesn't have a Depot account, or isn't signed in, the **Accept invite** link redirects them to sign in or sign up. After the user authenticates, they become an organization member and can access the organization in the Depot dashboard.
### Manage organization members with SSO
Single sign-on (SSO) with SCIM provisioning for Depot is an add-on feature. To learn more, get in touch at [contact@depot.dev](mailto:contact@depot.dev).
With SSO enabled, you configure your identity provider once through the Depot dashboard. Your identity provider handles Depot sign-ins and organization members.
### Delete an organization
To delete an organization, send a request to [help@depot.dev](mailto:help@depot.dev). Include the name of the organization you want to delete. We'll process the deletion manually to ensure all associated projects and runners are properly removed.
## Billing
Each Depot organization has its own [plan](/pricing) and billing. To view an organization's billing, payment, and plan details, go to the organization [Settings](/orgs/_/settings) page in your Depot dashboard.
You can access invoices from Stripe that contain VAT information through the Billing Portal in your organization [Settings](/orgs/_/settings).
For billing issues, see the [troubleshooting page](/docs/troubleshooting#billing).
## Quickstart for remote Claude Code agents on Depot
Run Claude Code agents in Depot's remote agent sandboxes: a secure, isolated environment in the cloud, where you can launch, resume, and share coding sessions.
## Prerequisites
You'll need a [Depot account](https://depot.dev/sign-up).
## Install the Depot CLI
Install the [Depot CLI](/docs/cli/reference) on your machine to configure and launch remote sandboxes.
* **macOS**
Install the Depot CLI with Homebrew:
```shell
brew install depot/tap/depot
```
* **Linux**
Install the Depot CLI with the installation script:
```shell
curl -L https://depot.dev/install-cli.sh | sh
```
* **All platforms**
Download the binary file for your platform from the [Depot CLI releases page](https://github.com/depot/cli/releases) in GitHub.
## Get and set your Anthropic credentials
To run Claude Code in remote agent sandboxes, configure your Anthropic credentials. You have two options:
* Claude Code token (Max plan)
* Anthropic API key
### Use your Claude Code token with Anthropic Max plan (recommended)
1. Use the `claude` CLI to generate a new OAuth token:
```shell
claude setup-token
```
This will output a token that you can copy to use in the next step.
2. Set the token as a secret in your Depot organization:
```shell
depot claude secrets add CLAUDE_CODE_OAUTH_TOKEN --value <"claude-code-token">
```
### Use your Anthropic API key
1. Generate an API key in the Anthropic web console. Learn how to get an API key in the [Claude Docs](https://docs.claude.com/en/api/overview).
2. Set the API key as a secret in your Depot organization:
```shell
depot claude secrets add ANTHROPIC_API_KEY --value <"anthropic-api-key">
```
## Access your Git repositories
You can work with public and private Git repositories in your remote agent sandboxes. To use private Git repositories, either install the Depot Code app into your GitHub organization or set your Git credentials as secrets in your Depot organization.
### Install the Depot Code app into your GitHub organization
To grant remote agent sandboxes access to clone and push changes to your private GitHub repositories, install the Depot Code app into your GitHub organization:
1. Log in to your [Depot dashboard](/orgs).
2. Click **Settings**.
3. In the **GitHub Code Access** section, click **Connect to GitHub**.
4. Follow the prompts to add Depot Code to your GitHub organization.
### Grant access outside of GitHub
If you don't want to use the Depot Code app, you can set your Git credentials as secrets in your Depot organization to allow changes to your private repositories. The value of `GIT_CREDENTIALS` must be one of the following:
* A token, such as a personal access token. Depot uses `x-token` as the username and the token you specify as the password.
* A user name and password in the format: username\@password.
To set your Git credentials as secrets, run the following command:
```shell
depot claude secrets add GIT_CREDENTIALS --value <"your-credentials">
```
## Launch your first remote agent sandbox
To create a remote agent sandbox, run the `depot claude` command. For example:
```shell
depot claude \
--session-id feature-auth \
--repository https://github.com/foo/bar \
--branch main \
"Give me a general summary of this repository"
✓ Claude sandbox started!
Session ID: feature-auth
Link: https://depot.dev/orgs/12345678911/claude/feature-auth
```
This command tells the Depot control plane to start a new agent sandbox for Claude Code. The command returns a URL to the session inside of Depot where you can follow the output.
And that's it! Your Depot organization is set up to use remote agent sandboxes for Claude Code.
## Manage sessions using the Depot dashboard
In addition to using the CLI, you can also manage your remote agent sandboxes directly from the Depot dashboard:
1. Log in to your [Depot dashboard](/orgs).
2. To view all your sessions, click **Claude Code**.
3. From this view, you can:
* **Resume existing sessions**: Click on any session to view its details, then use the prompt input at the bottom to resume the session with a new message.
* **Start new sessions**: Click the **New sandbox** button to launch a fresh Claude Code session in a new remote agent sandbox. You can select a repository, branch, and provide an initial prompt.
## Next steps
Try the following with your remote agent sandbox:
* Work with different Git repositories that your Git credentials or Depot Code app have access to.
* Switch between branches using the `--branch` flag.
* Resume a session using the `--resume` flag or via the Depot dashboard.
* Fork a new session from an existing session using the `--resume` and `--fork-session` flags together.
Run `depot claude --help` or check the [CLI reference](/docs/cli/reference/agents) to see all the available command options.
## Remote Agents
Depot's remote agent sandboxes provide a secure, isolated environment for running AI coding agents like Claude Code in the cloud. Allowing you to move your agent coding sessions off of your local machine and into fast remote environments where you can easily launch, resume, and share sessions.
Current agent sandboxes support Claude Code, with more agents coming soon. By default, running `depot claude` will start a new session in a remote sandbox.
Node.js SDK + Depot CLI
## Prerequisites
* A Depot account with an organization
* Node.js installed locally
* [Depot CLI](/docs/cli/installation) installed
## Setup
This tutorial uses code from our [example repository](https://github.com/depot/examples/tree/main/build-api). Clone it to follow along:
```shell
git clone https://github.com/depot/examples.git
cd examples/build-api
```
The example repository contains the following Node.js examples under (`nodejs/`):
* [`list-projects.js`](https://github.com/depot/examples/blob/main/build-api/nodejs/src/list-projects.js) - List all projects
* [`create-project.js`](https://github.com/depot/examples/blob/main/build-api/nodejs/src/create-project.js) - Create a new project
* [`delete-project.js`](https://github.com/depot/examples/blob/main/build-api/nodejs/src/delete-project.js) - Delete a project
* [`create-build.js`](https://github.com/depot/examples/blob/main/build-api/nodejs/src/create-build.js) - Build image with options (load/save/push)
To get started, install Node.js dependencies:
```bash
cd nodejs
npm install
```
## Step 1: Create an organization token
1. Navigate to your organization settings in the Depot dashboard
2. Scroll to **API Tokens** section
3. Enter a description (e.g., `test-token`) and click **Create token**
4. Copy the token and save it securely (you won't see it again)
Set the token as an environment variable:
```shell
export DEPOT_TOKEN=
```
## Step 2: Install Depot CLI
Install via curl:
```shell
curl -L https://depot.dev/install-cli.sh | sh
```
Or via Homebrew (macOS):
```shell
brew install depot/tap/depot
```
## Step 3: Create a project
Projects in Depot provide isolated builder infrastructure and cache storage. We recommend creating a separate project for each customer organization to maximize cache effectiveness and prevent cache poisoning.
To create a project, use the `ProjectService.createProject` method with your organization token:
```javascript
const {depot} = require('@depot/sdk-node')
const headers = {
Authorization: `Bearer ${process.env.DEPOT_TOKEN}`,
}
const result = await depot.core.v1.ProjectService.createProject(
{
name: 'my-project',
regionId: 'us-east-1',
cachePolicy: {keepBytes: 50 * 1024 * 1024 * 1024, keepDays: 14}, // 50GB, 14 days
},
{headers},
)
console.log(result.project.projectId)
```
Try it with the example: `node nodejs/src/create-project.js my-project`
Save the `projectId` from the output, you'll need it for builds.
Example output:
```text
_Project {
projectId: 'krt0wtn195',
organizationId: '3d1h48dqlh',
name: 'my-project',
regionId: 'us-east-1',
createdAt: Timestamp { seconds: 1708021346n, nanos: 83000000 },
cachePolicy: _CachePolicy { keepBytes: 53687091200n, keepDays: 14 }
}
```
## Step 4: Build a Docker image
To build an image, first register a build with the Build API using `BuildService.createBuild`. This returns a build ID and one-time build token that you pass to the Depot CLI:
```javascript
const {depot} = require('@depot/sdk-node')
const {exec} = require('child_process')
const headers = {
Authorization: `Bearer ${process.env.DEPOT_TOKEN}`,
}
// Register the build
const result = await depot.build.v1.BuildService.createBuild({projectId: ''}, {headers})
// Execute build with Depot CLI
exec(
'depot build --load .',
{
env: {
DEPOT_PROJECT_ID: '',
DEPOT_BUILD_ID: result.buildId,
DEPOT_TOKEN: result.buildToken,
},
},
(error, stdout, stderr) => {
if (error) {
console.error(`Error: ${error}`)
return
}
console.log(stdout)
},
)
```
Try it with the example: `node nodejs/src/create-build.js `
The `--load` flag downloads the built image to your local Docker daemon.
## Step 5: Run the container
List your local Docker images:
```shell
docker image ls
```
Run the built container:
```shell
docker run
```
You should see "Hello World" output from the Node.js application.
## Step 6: Save to a registry
### Push to Depot Registry
Instead of loading locally with `--load`, you can save the image to Depot Registry using the `--save` flag:
```javascript
exec('depot build --save .', {
env: {
DEPOT_PROJECT_ID: '',
DEPOT_BUILD_ID: result.buildId,
DEPOT_TOKEN: result.buildToken,
},
})
```
Try it: `node nodejs/src/create-build.js save`
The build output shows how to pull or push the saved image:
```text
Saved target:
To pull: depot pull --project
To push: depot push --project --tag
```
### Push to external registries
To push directly to Docker Hub, GHCR, ECR, or other registries during the build, use the `--push` flag with `--tag`:
```javascript
exec('depot build --push --tag docker.io/myuser/myapp:latest .', {
env: {
DEPOT_PROJECT_ID: '',
DEPOT_BUILD_ID: result.buildId,
DEPOT_TOKEN: result.buildToken,
},
})
```
First authenticate with `docker login`, then pushing to other registries simply requires setting the proper image name:
```shell
# Docker Hub
node nodejs/src/create-build.js push docker.io/myuser/myapp:latest
# GitHub Container Registry
node nodejs/src/create-build.js push ghcr.io/myorg/myapp:latest
# AWS ECR
node nodejs/src/create-build.js push 123456789012.dkr.ecr.us-east-1.amazonaws.com/myapp:latest
```
Go SDK + BuildKit
## Prerequisites
* A Depot account with an organization
* Go 1.21+ installed locally
## Setup
This tutorial uses code from our [example repository](https://github.com/depot/examples/tree/main/build-api). Clone it to follow along:
```shell
git clone https://github.com/depot/examples.git
cd examples/build-api
```
The Go examples use two packages:
* **Buf Connect API** (`buf.build/gen/go/depot/api`) - For project management
* **Depot Go SDK** (`github.com/depot/depot-go`) - For builds
Available examples:
* [`list-projects/main.go`](https://github.com/depot/examples/blob/main/build-api/go/list-projects/main.go) - List all projects
* [`create-project/main.go`](https://github.com/depot/examples/blob/main/build-api/go/create-project/main.go) - Create a new project
* [`delete-project/main.go`](https://github.com/depot/examples/blob/main/build-api/go/delete-project/main.go) - Delete a project
* [`create-build/main.go`](https://github.com/depot/examples/blob/main/build-api/go/create-build/main.go) - Build image (saved to Depot)
* [`build-and-push/main.go`](https://github.com/depot/examples/blob/main/build-api/go/build-and-push/main.go) - Build and push to external registry
Install dependencies:
```bash
cd go
go mod download
```
## Build flow overview
Building with the Go SDK involves three steps:
1. **Register a build** - Request a build from the Depot API
2. **Acquire a builder machine** - Get an ephemeral BuildKit machine with your project cache
3. **Build and push** - Connect to BuildKit and execute the build
See the complete implementation in [`build-and-push/main.go`](https://github.com/depot/examples/blob/main/build-api/go/build-and-push/main.go).
## Step 1: Create an organization token
1. Navigate to your organization settings in the Depot dashboard
2. Scroll to **API Tokens** section
3. Enter a description (e.g., `test-token`) and click **Create token**
4. Copy the token and save it securely (you won't see it again)
Set the token as an environment variable:
```shell
export DEPOT_TOKEN=
```
## Step 2: Create a project
Projects in Depot provide isolated builder infrastructure and cache storage. To create a project, use the Buf Connect API client with `ProjectService.CreateProject`:
```go
import (
"net/http"
corev1 "buf.build/gen/go/depot/api/protocolbuffers/go/depot/core/v1"
"buf.build/gen/go/depot/api/connectrpc/go/depot/core/v1/corev1connect"
"connectrpc.com/connect"
)
token := os.Getenv("DEPOT_TOKEN")
// Create the Project Service client
client := corev1connect.NewProjectServiceClient(
http.DefaultClient,
"https://api.depot.dev",
)
// Create a new project
req := connect.NewRequest(&corev1.CreateProjectRequest{
Name: "my-project",
RegionId: "us-east-1",
CachePolicy: &corev1.CachePolicy{
KeepGb: 50, // 50GB
KeepDays: 14, // 14 days
},
})
// Add authentication header
req.Header().Set("Authorization", fmt.Sprintf("Bearer %s", token))
resp, err := client.CreateProject(ctx, req)
if err != nil {
log.Fatal(err)
}
log.Printf("Project ID: %s", resp.Msg.Project.ProjectId)
```
Try it with the example: `go run ./create-project/main.go my-project`
Save the project ID, you'll need it for builds.
## Step 3: Register a build
To start a build, register it with the Build API using `build.NewBuild`. This returns a build ID and one-time build token:
```go
import (
"github.com/depot/depot-go/build"
cliv1 "github.com/depot/depot-go/proto/depot/cli/v1"
)
token := os.Getenv("DEPOT_TOKEN")
projectID := os.Getenv("DEPOT_PROJECT_ID")
build, err := build.NewBuild(ctx, &cliv1.CreateBuildRequest{
ProjectId: projectID,
}, token)
if err != nil {
log.Fatal(err)
}
// Report build result when finished
var buildErr error
defer build.Finish(buildErr)
```
The `build.Finish()` call reports success or failure back to Depot when your build completes.
## Step 4: Acquire a builder machine
With your build registered, acquire an ephemeral BuildKit machine using `machine.Acquire`. The machine comes pre-configured with your project's cache:
```go
import "github.com/depot/depot-go/machine"
buildkit, buildErr := machine.Acquire(ctx, build.ID, build.Token, "arm64")
if buildErr != nil {
return
}
defer buildkit.Release()
```
Specify `"arm64"` or `"amd64"` for your target platform. Released machines stay alive for 2 minutes to serve subsequent builds.
## Step 5: Connect to BuildKit
Connect to your BuildKit machine using `buildkit.Connect`:
```go
import "github.com/moby/buildkit/client"
buildkitClient, buildErr := buildkit.Connect(ctx)
if buildErr != nil {
return
}
```
This establishes a secure mTLS connection to the BuildKit endpoint.
## Step 6: Configure the build
Configure your build by creating a `SolveOpt` with your Dockerfile path, build context, and export settings:
```go
import (
"github.com/docker/cli/cli/config"
"github.com/moby/buildkit/session"
"github.com/moby/buildkit/session/auth/authprovider"
)
solverOptions := client.SolveOpt{
Frontend: "dockerfile.v0",
FrontendAttrs: map[string]string{
"filename": "Dockerfile",
"platform": "linux/arm64",
},
LocalDirs: map[string]string{
"dockerfile": ".",
"context": ".",
},
Exports: []client.ExportEntry{
{
Type: "image",
Attrs: map[string]string{
"name": "myuser/myapp:latest",
"oci-mediatypes": "true",
"push": "true",
},
},
},
Session: []session.Attachable{
authprovider.NewDockerAuthProvider(config.LoadDefaultConfigFile(os.Stderr), nil),
},
}
```
The `Session` uses your Docker credentials from `docker login` to authenticate registry pushes.
## Step 7: Stream build output (optional)
To monitor build progress, create a status channel and process BuildKit status messages:
```go
import "encoding/json"
buildStatusCh := make(chan *client.SolveStatus, 10)
go func() {
enc := json.NewEncoder(os.Stdout)
enc.SetIndent("", " ")
for status := range buildStatusCh {
_ = enc.Encode(status)
}
}()
```
This streams build progress in real-time as JSON.
## Step 8: Build and push
Execute the build with `buildkitClient.Solve`. BuildKit automatically reuses cached layers from your project:
```go
_, buildErr = buildkitClient.Solve(ctx, nil, solverOptions, buildStatusCh)
if buildErr != nil {
return
}
```
When complete, your image is pushed to the registry specified in the `Exports` configuration.
Try the complete example: `DEPOT_PROJECT_ID= go run ./build-and-push/main.go`
### Push to third-party registries
To push to external registries, configure the full registry path in your image name and provide authentication.
#### Set the full registry path:
```go
Exports: []client.ExportEntry{
{
Type: "image",
Attrs: map[string]string{
"name": "docker.io/myuser/myapp:latest", // or ghcr.io, ECR, etc.
"oci-mediatypes": "true",
"push": "true",
},
},
},
```
The `build-and-push` example supports two options for authentication:
#### Option 1: Docker login credentials (default)
After running `docker login`, BuildKit automatically uses credentials from `~/.docker/config.json`:
```bash
docker login docker.io
DEPOT_PROJECT_ID= go run ./build-and-push/main.go docker.io/user/app:latest
```
#### Option 2: Programmatic credentials (for CI/CD)
Provide credentials via environment variables:
```bash
DEPOT_PROJECT_ID= \
REGISTRY_USERNAME=myuser \
REGISTRY_PASSWORD=mytoken \
REGISTRY_URL=https://index.docker.io/v1/ \
go run ./build-and-push/main.go docker.io/user/app:latest
```
The example automatically detects which method to use based on the presence of `REGISTRY_USERNAME` and `REGISTRY_PASSWORD`.
See the complete working examples in the repository: [`go/create-build/main.go`](https://github.com/depot/examples/blob/main/build-api/go/create-build/main.go) and [`go/build-and-push/main.go`](https://github.com/depot/examples/blob/main/build-api/go/build-and-push/main.go).
For a raw narrative version of this pattern, see the blog post [The End of push-wait-guess CI](/blog/the-end-of-push-wait-guess-ci).
## Why the CLI works well for agents
Most coding agents already have a shell. The Depot CLI gives them CI without any HTTP plumbing. `depot ci run` tests workflows against your local working tree without requiring a commit or push. That's what makes the agent loop work: the agent can edit code and rerun CI in a tight loop without polluting the git history or waiting on long-running CI in GitHub.
* `depot ci run` starts a run against your local working tree. Use `--job` to scope to specific jobs for faster iteration. The CLI resolves job dependencies automatically.
* `depot ci status` shows the full run hierarchy, workflows, jobs, and attempts with their statuses.
* `depot ci logs` fetches the log output for a failed job so the agent can read the error and fix it.
* `depot ci ssh` connects directly to a running sandbox via the Depot API, giving you (or the agent) an interactive shell on the sandbox. To keep a sandbox alive at the right moment, use `depot ci run --ssh-after-step 
Use these controls to find the run you need:
* **Search**: Type in the search box at the top to filter workflows by name.
* **Status tabs**: Click **All**, **Running**, **Failed**, or **Passed** to filter by run status. You can also filter by repository, trigger, SHA, run ID, PR number or workflow ID.
From the command line, you can use [`depot ci run list`](/docs/cli/reference/depot-ci#depot-ci-run-list) to list recent queued and running runs, and [`depot ci status`](/docs/cli/reference/depot-ci#depot-ci-status) to view the status of a specific run.
## View logs for a job
Select a job to load its logs. The log viewer displays the full output organized by step. Each step shows its name on the left and duration on the right. A visual timing bar indicates relative duration for longer-running steps.
Click a step name to collapse or expand its log output. Use **Expand all** in the toolbar to open all steps at once. Use the filter box to search logs by keyword, and the download or copy buttons to export the log output.
You can also fetch logs from the command line with [`depot ci logs`](/docs/cli/reference/depot-ci#depot-ci-logs), which prints a job attempt's log output to stdout. Add `--follow` (or `-f`) to stream a running job's logs as they're produced, or pass `--follow` to [`depot ci run`](/docs/cli/reference/depot-ci#depot-ci-run) to start a run and follow its logs in one command. To read logs programmatically, use the [Depot CI API](/docs/api/ci/reference).
## Link to a job from within a workflow
Every Depot CI job sets a `DEPOT_JOB_URL` environment variable containing a direct link to that job attempt's page in the Depot dashboard. Use it to surface the run from any step, such as a Slack message, a GitHub comment, or a custom webhook notification. For example:
```yaml
- name: Notify Slack
run: |
curl -X POST $SLACK_WEBHOOK \
-H 'Content-type: application/json' \
-d "{\"text\": \"Build finished: $DEPOT_JOB_URL\"}"
```
For the list of variables Depot CI sets in every job, see the [environment variables reference](/docs/environment-variables#depot-ci).
## Depot CI metrics
## View job metrics
From the [Depot CI page](/orgs/_/workflows), click a workflow run and select a specific job to view its metrics.
### Sandbox resource utilization
The **Resource Usage** section above the logs displays CPU and memory utilization graphs for the job's sandbox. Use these graphs to determine if jobs are resource-constrained or over-provisioned.
Annotations on the graph mark the start of each step. Click an annotation to jump to the corresponding step in the log output.
### Step-level timing
Each step in the job shows its name and duration. A visual timing bar indicates relative duration for longer-running steps, making it easy to spot bottlenecks like dependency installation or test execution.
### AI failure diagnosis
When a job fails, Depot analyzes the failure and displays a **Failure Diagnosis** section at the top of the job detail view when a diagnosis is available. The diagnosis includes:
* **What went wrong**: An AI-generated explanation of the root cause based on the job's logs and error output.
* **Suggested fix**: Actionable steps to resolve the issue.
For deeper investigation, you can [debug a failing job with SSH](/docs/ci/how-to-guides/debug-with-ssh) to connect directly to the sandbox environment. For viewing and navigating job logs, see [Depot CI logs](/docs/ci/observability/depot-ci-logs).
You can also fetch job and run metrics programmatically with the [Depot CI API](/docs/api/ci/reference).
## Depot CI test results
| GitHub Actions compatibility |
|
| Fast runs |
|
| Custom images |
|
| Nested virtualization |
|
| Built-in debuggability |
|
| Local workflow runs |
|
| OIDC for cloud authentication |
|
| API and CLI for engineers and agents |
|
| Workflows, logs, and metrics in the dashboard |
|
+ $0.0001/second after | 20,000 included min/month
+ $0.0001/second after | Custom | | **Cache** | 25 GB included
+ $0.20/GB/month after | 250 GB included
+ $0.20/GB/month after | Custom |
.github/ to .depot/ 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.
depot ci migrate command copies your workflows and analyzes them for any compatibility issues before you
commit.
.github/workflows/ files remain untouched and continue running on GitHub.
Depot CI runs the copies in .depot/workflows/ 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.
depot ci run command submits a local workflow file to Depot CI and applies any uncommitted
changes automatically. You can also pass --job to run a subset of jobs and --ssh-after-step{' '}
to open an interactive SSH debug session at a specific step.