Quickstart

Create a machine, run a command, retrieve output, then open SSH.

CLI

Control machines from a terminal, script, or agent.

Install the CLI

curl -fsSL https://raw.githubusercontent.com/dedalus-labs/dedalus-cli/main/scripts/install.sh | bash

brew install dedalus-labs/tap/dedalus

irm https://raw.githubusercontent.com/dedalus-labs/dedalus-cli/main/scripts/install.ps1 | iex

git clone https://github.com/dedalus-labs/dedalus-cli.git
cd dedalus-cli
go install ./cmd/dedalus

Set your API key

Get a Dedalus API key from the Dashboard and set it in your shell.

export DEDALUS_API_KEY="dsk_your_api_key"

Create a machine

The CLI calls the Machines API.

dedalus machines create

Every flag is optional. With no flags you get a 1 vCPU machine with 4096 MiB of memory, 10 GiB of storage, and a 5-minute autosleep window. Pass --vcpu, --memory-mib, --storage-gib, or --autosleep to override.Save the machine_id. Later commands use it.

{
  "machine_id": "dm-...",
  "vcpu": 1,
  "memory_mib": 4096,
  "storage_gib": 10,
  "autosleep_seconds": 300,
  "desired_state": "running",
  "status": {
    "phase": "accepted",
    "reason": "Accepted",
    "retryable": true,
    "revision": "1",
    "last_transition_at": "2026-06-18T00:00:00Z",
    "last_progress_at": "2026-06-18T00:00:00Z"
  }
}

Run a command

The CLI runs commands directly, without opening a shell.

Machine IDs start with dm-.

dedalus machines executions create \
  --machine-id dm-... \
  --command '["/bin/bash", "-c", "whoami && uname -a"]'

Save the execution_id. Use it to retrieve the result.

{
  "execution_id": "wexec-...",
  "machine_id": "dm-...",
  "status": "queued",
  "command": ["/bin/bash", "-c", "whoami && uname -a"],
  "created_at": "2026-06-18T00:00:02Z"
}

Get the result

Poll the execution until its status is succeeded, then fetch the captured output.

MACHINE_ID=dm-...
EXECUTION_ID=wexec-...
dedalus machines executions retrieve \
  --machine-id "$MACHINE_ID" \
  --execution-id "$EXECUTION_ID"

dedalus machines executions output \
  --machine-id "$MACHINE_ID" \
  --execution-id "$EXECUTION_ID"

SSH

Use executions for agents. Use SSH for human shells and debugging. Install packages and run normal Linux commands.

dedalus ssh dm-...

# Inside the machine:
whoami && uname -a

SDK

These examples create a machine, run a command, and print output.

import time

from dedalus_sdk import Dedalus

client = Dedalus()
DONE = {"succeeded", "failed", "cancelled", "expired"}

dm = client.machines.create(vcpu=1, memory_mib=1024, storage_gib=10)
stream = client.machines.watch(machine_id=dm.machine_id)
for _ in stream:
    pass

exc = client.machines.executions.create(
    machine_id=dm.machine_id,
    command=["/bin/bash", "-c", "whoami && uname -a"],
)
while exc.status not in DONE:
    time.sleep(0.5)
    exc = client.machines.executions.retrieve(
        machine_id=dm.machine_id,
        execution_id=exc.execution_id,
    )
if exc.status != "succeeded":
    raise RuntimeError(f"{exc.status}: {exc.error_code}: {exc.error_message}")

out = client.machines.executions.output(
    machine_id=dm.machine_id,
    execution_id=exc.execution_id,
)
print(out.stdout)

import Dedalus from "dedalus";

const client = new Dedalus();
const DONE = new Set(["succeeded", "failed", "cancelled", "expired"]);
const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));

const dm = await client.machines.create({
  vcpu: 1,
  memory_mib: 1024,
  storage_gib: 10,
});
const stream = await client.machines.watch({ machine_id: dm.machine_id });
for await (const _ of stream) {}

let exc = await client.machines.executions.create({
  machine_id: dm.machine_id,
  command: ["/bin/bash", "-c", "whoami && uname -a"],
});
while (!DONE.has(exc.status)) {
  await sleep(500);
  exc = await client.machines.executions.retrieve({
    machine_id: dm.machine_id,
    execution_id: exc.execution_id,
  });
}
if (exc.status !== "succeeded") {
  throw new Error(`${exc.status}: ${exc.error_code}: ${exc.error_message}`);
}

const out = await client.machines.executions.output({
  machine_id: dm.machine_id,
  execution_id: exc.execution_id,
});
console.log(out.stdout);

package main

import (
    "context"
    "fmt"
    "time"

    dedalus "github.com/dedalus-labs/dedalus-go"
)

func main() {
    client := dedalus.NewClient()
    ctx := context.Background()
    done := map[dedalus.ExecutionStatus]bool{
        dedalus.ExecutionStatusSucceeded: true,
        dedalus.ExecutionStatusFailed:    true,
        dedalus.ExecutionStatusCancelled: true,
        dedalus.ExecutionStatusExpired:   true,
    }

    dm, err := client.Machines.New(ctx, dedalus.MachineNewParams{
        CreateParams: dedalus.CreateParams{
            VCPU: 1, MemoryMiB: 1024, StorageGiB: 10,
        },
    })
    check(err)
    stream := client.Machines.WatchStreaming(ctx, dedalus.MachineWatchParams{
        MachineID: dm.MachineID,
    })
    for stream.Next() {
    }
    check(stream.Err())

    exc, err := client.Machines.Executions.New(ctx, dedalus.MachineExecutionNewParams{
        MachineID: dm.MachineID,
        ExecutionCreateParams: dedalus.ExecutionCreateParams{
            Command: []string{"/bin/bash", "-c", "whoami && uname -a"},
        },
    })
    check(err)

    for !done[exc.Status] {
        time.Sleep(500 * time.Millisecond)
        exc, err = client.Machines.Executions.Get(ctx, dedalus.MachineExecutionGetParams{
            MachineID: dm.MachineID, ExecutionID: exc.ExecutionID,
        })
        check(err)
    }
    if exc.Status != dedalus.ExecutionStatusSucceeded {
        panic(fmt.Sprintf("%s: %s", exc.ErrorCode, exc.ErrorMessage))
    }

    out, err := client.Machines.Executions.Output(ctx, dedalus.MachineExecutionOutputParams{
        MachineID: dm.MachineID, ExecutionID: exc.ExecutionID,
    })
    check(err)
    fmt.Println(out.Stdout)
}

func check(err error) {
    if err != nil {
        panic(err)
    }
}

Next: sleep, wake, watch, or delete the machine in Lifecycle.

Dedalus Cloud Services

Dedalus Machines

Pricing

CLI

SSH

SDK

​CLI

​SSH

​SDK

CLI

SSH

SDK