<img src="https://raw.githubusercontent.com/dagu-org/dagu/HEAD/assets/images/hero-logo.png" width="720" alt="Dagu: built for teams whose main work is not orchestration">

<a href="https://docs.dagu.sh">Docs</a> ·
<a href="https://docs.dagu.sh/getting-started/cli">CLI</a> ·
<a href="https://petstore.swagger.io/?url=https://raw.githubusercontent.com/dagucloud/dagu/main/api/v1/api.yaml">API</a> ·
<a href="https://docs.dagu.sh/writing-workflows/examples">Examples</a> ·
<a href="https://dagu-demo-f5e33d0e.dagu.sh">Live demo</a>
<code>(username/password: demouser)</code> ·
<a href="https://discord.gg/gpahPUjGRk">Discord</a>

Dagu

• Single binary file installation.
• Self-contained, with no need for a DBMS or message broker.
• Runs on Linux, macOS, and Windows.
• Declarative YAML format for defining DAGs.
• Run existing shell commands, Docker containers, Kubernetes Jobs, and remote commands over SSH without modifications.
• Compose reusable Sub-DAGs and run work in parallel with concurrency controls.
• Schedule workflows with cron syntax, timezones, overlap policies, and catch-up windows.
• Keep logs, run history, retries, notifications, and webhook triggers in one place.
• Built-in MCP support for AI agents to manage workflows.
• Run external coding-agent CLIs through harness.run when workflows need AI assistance.

Quick Look

<img src="https://raw.githubusercontent.com/dagu-org/dagu/HEAD/assets/images/cockpit-demo-poster.jpg" width="720" alt="Dagu Cockpit showing queued, running, completed, and failed workflow runs">

Run Details	Step Logs	Wiki

Why Dagu?

• cron runs commands, but gives you no dependencies, no retries, no history.
• Airflow orchestrates, but you operate a platform for it (scheduler, metadata database, workers, a Python environment), and your jobs get rewritten as @dag/@task framework code.
• Temporal gives durable execution, but your business logic moves into its SDK and programming model.

Traditional Orchestrator          Dagu
┌────────────────────────┐        ┌──────────────────┐
│  Web Server            │        │                  │
│  Scheduler             │        │  dagu start-all  │
│  Worker(s)             │        │                  │
│  PostgreSQL            │        └──────────────────┘
│  Redis / RabbitMQ      │         Single binary.
│  Python Runtime        │         Self-hosted.
└────────────────────────┘         Adds scheduling, retries, and human tasks around existing automation.
  6+ services to manage

Performance

• Throughput: A single machine can run thousands of workflow runs per day. Actual capacity depends on CPU, memory, disk, and workflow shape.
• Load control: Queues, concurrency limits, and resource limits control how many runs execute at once and where they run.
• Scale out: Distributed workers spread execution across machines when one node is not enough.

Real-World Use Cases

Quick Start

Install

curl -fsSL https://raw.githubusercontent.com/dagucloud/dagu/main/scripts/installer.sh | bash

brew install dagu

npm install -g --ignore-scripts=false @dagucloud/dagu

irm https://raw.githubusercontent.com/dagucloud/dagu/main/scripts/installer.ps1 | iex

docker run --rm -v ~/.dagu:/var/lib/dagu -p 8080:8080 ghcr.io/dagucloud/dagu:latest dagu start-all

helm repo add dagu https://dagucloud.github.io/dagu
helm repo update
helm install dagu dagu/dagu --set persistence.storageClass=<your-rwx-storage-class>

Replace <your-rwx-storage-class> with a StorageClass that supports ReadWriteMany. See charts/dagu/README.md for chart configuration.

Create and run a workflow

steps:
  - id: hello
    run: echo "hello from Dagu"

dagu start hello.yaml

Start the server

dagu start-all --dags .

How You Run Dagu?

<td width="50%" align="center" valign="top">
  <strong>Single Server</strong><br>
  <img src="https://raw.githubusercontent.com/dagu-org/dagu/HEAD/assets/images/deployment-model-local.gif" width="100%" alt="Single-server deployment model with one Dagu server handling scheduling and execution.">
</td>
<td width="50%" align="center" valign="top">
  <strong>Distributed Workers</strong><br>
  <img src="https://raw.githubusercontent.com/dagu-org/dagu/HEAD/assets/images/deployment-model-self-hosted.gif" width="100%" alt="Distributed-workers deployment model with the Dagu server dispatching to workers on separate machines.">
</td>

Licensing

• Community self-host: No license key required. You operate the server, storage, upgrades, networking, and workers. Start with the installation guide.
• Self-host license: Adds SSO, RBAC, audit logging, and incident SaaS integration to Dagu. See self-host licensing.

Key Features

• Observability: Shared workflows and scheduling with clear visualizations, status tracking, and logs in the Web UI.
• Language-agnostic: No framework required. Define workflow steps using shell commands, Docker containers, Kubernetes Jobs, SQL queries, HTTP requests, and any other tool via official and third-party Dagu Actions.
• Build workflows: Reuse a step's result when its command and files have not changed. Dagu can also infer dependencies from matching file paths.
• Reproducibility: Reproducible runs with pinned tools, plus automatic installation and caching on workers—eliminating the need to manually install dependencies on the server or workers.
• Human Tasks: Pause a workflow for acknowledgement or typed operator input, then expose the response to downstream steps.
• Secret management: Built-in secret management with secure log masking, preventing credentials from leaking into logs or the Web UI.
• Self-hosted: A single binary that runs on Linux, macOS, and Windows. Includes an optional distributed worker mode for scaling out execution across machines.
• Permission Control: RBAC and SSO support for team environments, controlling who can view, run, and edit workflows through granular permissions and audit logging.
• MCP Server: Built-in MCP server for authoring and running workflows via AI agents like Claude Code, Codex, Gemini CLI, Pi, OpenCode, and more.
• External CLI Harness: You can run coding-agent CLIs (Claude Code, Codex, Gemini CLI, Pi, OpenCode, etc.) with a built-in harness action or custom harness definition.

Architecture

Standalone:

  ┌─────────────────────────────────────────┐
  │  dagu start-all                         │
  │  ┌───────────┐ ┌───────────┐ ┌────────┐ │
  │  │ HTTP / UI │ │ Scheduler │ │Executor│ │
  │  └───────────┘ └───────────┘ └────────┘ │
  │  File-based storage (logs, state, queue)│
  └─────────────────────────────────────────┘

Distributed:

  ┌────────────┐                   ┌────────────┐
  │ Scheduler  │                   │ HTTP / UI  │
  │            │                   │            │
  │ ┌────────┐ │                   └─────┬──────┘
  │ │ Queue  │ │  Dispatch (gRPC)        │ Dispatch / GetWorkers
  │ │(file)  │ │─────────┐               │ (gRPC)
  │ └────────┘ │         │               │
  └────────────┘         ▼               ▼
                    ┌─────────────────────────┐
                    │      Coordinator        │
                    │  ┌───────────────────┐  │
                    │  │ Dispatch Task     │  │
                    │  │ Store (pending/   │  │
                    │  │ claimed)          │  │
                    │  └───────────────────┘  │
                    └────────▲────────────────┘
                             │
                   Worker poll / task response
                   Heartbeat / ReportStatus /
                   StreamLogs (gRPC)
                             │
               ┌─────────────┴─────────────┐
               │             │             │
          ┌────┴───┐    ┌────┴───┐    ┌────┴───┐
          │Worker 1│    │Worker 2│    │Worker N│ Sandbox execution of DAGs
          │        │    │        │    │        │
          └────────┘    └────────┘    └────────┘

Parameter Definition

params:
  - name: customer_id
    type: string
    description: Customer or account identifier
  - name: change_scope
    type: string
    description: What the repair is allowed to change
    enum:
      - metadata_only
      - permissions
      - full_account
    default: metadata_only
  - name: dry_run
    type: boolean
    default: true

steps:
  - id: extract
    run: >-
      ./scripts/extract.sh
      --customer "${params.customer_id}"
      --scope "${params.change_scope}"
      --dry-run="${params.dry_run}"
    retry_policy:
      limit: 3
      interval_sec: 30

Workflow Examples

Docker step

steps:
  - name: build
    container:
      image: node:20-alpine
    run: npm run build

Parallel Sub-DAG execution

steps:
  - id: patch
    action: dag.run
    with:
      dag: patch-host
      params:
        host: ${ITEM}
    parallel:
      items:
        - web-1.internal
        - web-2.internal
        - db-1.internal
      max_concurrent: 2

---

name: patch-host
params:
  - name: host
    type: string
ssh:
  user: deploy
  host: ${params.host}
steps:
  - id: apply
    run: apt-get update -q && apt-get upgrade -y

SSH remote execution

ssh:
  user: deploy
  host: web-1.internal
  key: ~/.ssh/deploy_key

steps:
  - id: health
    run: curl -f http://localhost:8080/health
    retry_policy:
      limit: 3
      interval_sec: 10

  - id: restart
    run: systemctl restart myapp
    depends: health

Scheduling with overlap control and catch-up

schedule:
  - "0 */6 * * *"          # Every 6 hours
overlap_policy: skip       # Skip if previous run is still active
catchup_window: "5h"       # Catch up missed runs when scheduler is down for up to 5 hours

timeout_sec: 3600
handler_on:
  failure:
    run: notify-team.sh
  exit:
    run: cleanup.sh

Retry and error handling

steps:
  - name: flaky-api-call
    run: curl -f https://api.example.com/data
    retry_policy:
      limit: 3
      interval_sec: 10
    continue_on:
      failure: true

More Workflow Examples

Parallel executions

steps:
  - id: extract
    run: ./extract.sh

  - id: transform_a
    run: ./transform_a.sh
    depends: extract

  - id: transform_b
    run: ./transform_b.sh
    depends: extract

  - id: load
    run: ./load.sh
    depends: [transform_a, transform_b]

%%{init: {'theme': 'base', 'themeVariables': {'background': '#18181B', 'primaryTextColor': '#fff', 'lineColor': '#888'}}}%%
graph LR
    A[extract] --> B[transform_a]
    A --> C[transform_b]
    B --> D[load]
    C --> D
    style A fill:#18181B,stroke:#22C55E,stroke-width:1.6px,color:#fff
    style B fill:#18181B,stroke:#22C55E,stroke-width:1.6px,color:#fff
    style C fill:#18181B,stroke:#22C55E,stroke-width:1.6px,color:#fff
    style D fill:#18181B,stroke:#3B82F6,stroke-width:1.6px,color:#fff

Reuse unchanged results

type: build
working_dir: .

steps:
  - id: uppercase
    inputs:
      - name: source
        path: source.txt
    outputs:
      - name: result
        path: uppercase.txt
    run: |
      #!/bin/sh
      tr '[:lower:]' '[:upper:]' < "${inputs.source}" > "${outputs.result}"

printf 'alpha\n' > source.txt
dagu start workflow.yaml

External tools with pinning and caching

tools:
  - jqlang/[email protected]

steps:
  - id: inspect
    run: jq --version

  - id: summarize
    action: python-script@v1
    with:
      input:
        rows: [42, 8]
      script: |
        return {"total": sum(input["rows"])}

Third-party Dagu Actions

params:
  - BUILD_ID

steps:
  - id: notify
    action: acme/[email protected]
    with:
      text: "Build ${params.BUILD_ID} finished"

  - id: audit
    depends: notify
    run: 'echo "Notification result: ${steps.notify.outputs.messageId}"'

Kubernetes Pod execution

steps:
  - name: batch-job
    action: kubernetes.run
    with:
      namespace: production
      image: my-registry/batch-processor:latest
      resources:
        requests:
          cpu: "2"
          memory: "4Gi"
      command: ./process.sh

Additional Capabilities

AI and agent integrations

gh skill install dagucloud/dagu dagu

Built-in Actions

Custom Actions

actions:
  webhook.send:
    input_schema:
      type: object
      additionalProperties: false
      required: [url, text]
      properties:
        url:
          type: string
        text:
          type: string
    template:
      action: http.request
      with:
        method: POST
        url: '{{ .input.url }}'
        headers:
          Content-Type: application/json
        body: |
          {"text": {{ json .input.text }}}

steps:
  - action: webhook.send
    with:
      url: https://hooks.example.com/ops
      text: deploy complete

Official Dagu Actions

Security and Access Control

Authentication

• none — No authentication
• basic — HTTP Basic authentication
• builtin — JWT-based authentication with user management, API keys, per-DAG webhook tokens, and optional OIDC/SSO integration

Role-Based Access Control

TLS and Secrets

• TLS for the HTTP server (DAGU_CERT_FILE, DAGU_KEY_FILE)
• Mutual TLS for gRPC coordinator/worker communication (DAGU_PEER_CERT_FILE, DAGU_PEER_KEY_FILE, DAGU_PEER_CLIENT_CA_FILE)
• Secret management with environment variables, files, Kubernetes Secrets, HashiCorp Vault, and cloud-provider secret stores

Production Hardening

• Prefer auth.mode: builtin for any shared or network-exposed instance. Use basic only for simple private setups, and avoid none outside isolated local development.
• Keep metrics: private unless the metrics endpoint is reachable only on a trusted private network.
• Bind Dagu to loopback or a private interface when possible. If you must use 0.0.0.0, place it behind a trusted reverse proxy, TLS, and network-level access controls.
• Leave terminal.enabled: false unless the instance is admin-only and tightly scoped.
• In distributed deployments, set peer.insecure=false and configure peer TLS when coordinator and workers communicate across host or network boundaries.
• Treat Docker socket mounts, root containers, and host-level executors as privileged access to the underlying machine.

Observability

Prometheus Metrics

• dagu_info — Build information (version, Go version)
• dagu_uptime_seconds — Server uptime
• dagu_dag_runs_total — Total DAG runs by status
• dagu_dag_runs_total_by_dag — Per-DAG run counts
• dagu_dag_run_duration_seconds — Histogram of run durations
• dagu_dag_runs_currently_running — Active DAG runs
• dagu_dag_runs_queued_total — Queued runs
• dagu_workers_registered — Registered distributed workers
• dagu_worker_info — Worker heartbeat labels as key/value metadata
• dagu_worker_heartbeat_timestamp_seconds — Last worker heartbeat timestamp
• dagu_worker_health_status — Worker health by heartbeat freshness
• dagu_worker_pollers — Worker poller capacity by state
• dagu_worker_running_tasks — Running tasks per worker
• dagu_worker_oldest_running_task_age_seconds — Age of the oldest running task per worker

Structured Logging

Notifications

• Email notifications on DAG success, failure, or wait status via SMTP
• Per-DAG webhook endpoints with token authentication

Artifacts

Scheduling and Reliability

• Cron scheduling with timezone support and multiple schedule entries per DAG
• Overlap policies: skip (default — skip if previous run is still active), all (queue all), latest (keep only the most recent)
• Catch-up scheduling: Automatically runs missed intervals when the scheduler was down
• Zombie detection: Identifies and handles stalled DAG runs (configurable interval, default 45s)
• Retry policies: Per-step retry with configurable limits, intervals, and exit code filtering
• Human tasks: Pause root DAG runs for acknowledgement or schema-validated operator input, locally or on distributed workers, then expose form values to downstream steps
• Lifecycle hooks: onInit, onSuccess, onFailure, onAbort, onExit, onWait
• Preconditions: Gate DAG or step execution on shell command results
• High availability: Scheduler lock with stale detection for failover

Distributed Execution

• Coordinator: gRPC server that manages task distribution, worker registry, and health monitoring
• Workers: Connect to the coordinator, pull tasks from the queue, execute DAGs locally, report results
• Worker labels: Route DAGs to specific workers based on labels (e.g., gpu=true, region=us-east-1)
• Health checks: HTTP health endpoints on coordinator and workers for load balancer integration
• Queue system: File-based persistent queue with configurable concurrency limits

# Start coordinator
dagu coordinator

# Start workers (on separate machines)
DAGU_WORKER_LABELS=gpu=true,memory=64G dagu worker

CLI Reference

Environment Variables

Server

Paths

paths:
  dag_run_work_dir: /mnt/dagu/dag-run-work

dag_discovery:
  recursive: true

Authentication

Scheduler

Coordinator / Worker

Peer TLS (gRPC)

Git Sync

Embedded Go API (Experimental)

import "github.com/dagucloud/dagu/v2"

engine, err := dagu.New(ctx, dagu.Options{
	HomeDir: "/var/lib/myapp/dagu",
})
if err != nil {
	return err
}
defer engine.Close(context.Background())

run, err := engine.RunYAML(ctx, []byte(`
params:
  - MESSAGE
steps:
  - name: hello
    run: echo "${params.MESSAGE}"
`), dagu.WithParams(map[string]string{
	"MESSAGE": "hello from the host app",
}))
if err != nil {
	return err
}

status, err := run.Wait(ctx)
if err != nil {
	return err
}
fmt.Println(status.Status)

Community

• Discord — Questions and discussion
• GitHub Issues — Bug reports and feature requests
• Bluesky

Development

git clone https://github.com/dagucloud/dagu.git && cd dagu
make build    # Build frontend + Go binary
make test     # Run tests with race detection
make lint     # Run golangci-lint

Acknowledgements

<img src="https://wsrv.nl/?url=https%3A%2F%2Fslashbinlabs.com%2Flogo.png&w=150&h=150&fit=cover&mask=circle" width="100" height="100" alt="/bin labs">

<a href="https://github.com/gyger">
  <img src="https://wsrv.nl/?url=https%3A%2F%2Fgithub.com%2Fgyger.png&w=128&h=128&fit=cover&mask=circle" width="50" alt="@gyger">
</a>
<a href="https://github.com/disizmj">
  <img src="https://wsrv.nl/?url=https%3A%2F%2Fgithub.com%2Fdisizmj.png&w=128&h=128&fit=cover&mask=circle" width="50" alt="@disizmj">
</a>
<a href="https://github.com/Arvintian">
  <img src="https://wsrv.nl/?url=https%3A%2F%2Fgithub.com%2FArvintian.png&w=128&h=128&fit=cover&mask=circle" width="50" alt="@Arvintian">
</a>
<a href="https://github.com/yurivish">
  <img src="https://wsrv.nl/?url=https%3A%2F%2Fgithub.com%2Fyurivish.png&w=128&h=128&fit=cover&mask=circle" width="50" alt="@yurivish">
</a>
<a href="https://github.com/jayjoshi64">
  <img src="https://wsrv.nl/?url=https%3A%2F%2Fgithub.com%2Fjayjoshi64.png&w=128&h=128&fit=cover&mask=circle" width="50" alt="@jayjoshi64">
</a>
<a href="https://github.com/alangrafu">
  <img src="https://wsrv.nl/?url=https%3A%2F%2Fgithub.com%2Falangrafu.png&w=128&h=128&fit=cover&mask=circle" width="50" alt="@alangrafu">
</a>

<img src="https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&color=%23fe8e86" width="150" alt="Sponsor">

Contributing

License