A task orchestration system designed to be efficient, fast, developer-friendly, and easy to scale. Built on the Erlang VM, Gust recovers gracefully from failures, supports manual retries, and is production-ready.

---

Why Gust

Running task orchestration in production often means:

• Standing up and maintaining multiple databases and services just to keep the scheduler alive.
• Fighting Docker complexity before a single DAG runs.
• Living with a clunky, outdated UI that slows debugging down.

Gust strips that away. One system, minimal moving parts, efficient and with a UI built for speed so you spend time writing DAGs, not babysitting infrastructure.

---

Table of Contents

• Overview
• Getting Started
• Features
• Guides
• Examples
• Benchmark

---

Overview

From code to running workflow: you (or your agent) write a DAG, save it in the dags/ folder, and Gust picks it up. Once loaded, the DAG shows up in the Web UI, ready to be triggered manually or to run on its own if a schedule is set.

DAG Code Example

defmodule HelloGust do
  @moduledoc false
  use Gust.DSL

  require Logger
  alias Gust.Flows

  task :first_task, downstream: [:second_task], save: true do
    greetings = "Hi from first_task"
    Logger.info(greetings)
    greetings = ["Hello!", "Olá!", "¡Hola!", "Bonjour!"]

    # You can get secrets created on the Web UI
    secret = Flows.get_secret_by_name("SUPER_SECRET")

    if secret do
      Logger.warning("I know your secret: #{secret.value}")
    end

    # The return value must be a map or a list when `save` is true.
    greetings
  end

  task :second_task,
    downstream: [:final_task],
    ctx: %{params: params},
    map_over: :first_task,
    save: true do
    message = "#{params["item"]} World!"
    Logger.warning(message)
    %{greeting: message}
  end

  task :final_task, ctx: %{run_id: run_id} do
    # Getting tasks results
    second_tasks = Flows.get_tasks_by_name("second_task", run_id)

    Enum.each(second_tasks, fn task ->
      Logger.warning(inspect(task.result))
    end)
  end
end

---

Getting started

• Quickstart with Docker
• Setup a new Gust project

---

Features

• Task orchestration with Cron-style scheduling and dependency-aware DAGs via the Gust DSL.
• YAML and Shell DAG support for orchestrating shell commands and scripts.
• Parallel task mapping with :map_over, creating one task instance per upstream list item.
• Conditional task skipping with :skip_if; dependent downstream tasks are skipped when an upstream task is skipped.
• Durable task waiting with :wait_for, so a DAG can pause until another DAG, webhook, or external process resumes it.
• Support multiple nodes.
• Support for Python DAGs
• Manual task controls: stop running tasks, cancel retries, and restart tasks on demand.
• Run-time tracking, corrupted-state recovery, and graceful handling of syntax errors during development.
• Retry logic with backoff, plus state clearing for clean restarts.
• Hook for finished dag run.
• Web UI for live monitoring, runs and secrets editing.

---

MCP Server

GustWeb includes a built-in MCP server that gives your LLM access to Gust’s core features, including listing DAGs, triggering runs, exploring DAG definitions, and debugging executions.

To mount it in your Phoenix router:

import GustWeb.MCPRouter

scope "/mcp", MyAppWeb do
  pipe_through :api
  gust_mcp_server()
end

The prefix comes from your MyAppWeb router scope, so you can also mount it under a project-specific path to avoid clashes:

scope "/gust/mcp", MyAppWeb do
  pipe_through :api
  gust_mcp_server()
end

That would expose POST /gust/mcp/server. Keep auth and any app-specific policy outside the macro, at the router scope or pipeline level.

Connect to an MCP client

• claude: claude mcp add --transport http gust-mcp http://localhost:4000/gust/mcp/server
• codex: codex mcp add gust-mcp --url http://localhost:4000/gust/mcp/server

Skills

• Available Skills

• Install

gh skill install marciok/gust elixir-dag-creator

---

Guides

Gust

• Writing DAGs
• Configuration
• Gust Roles
• Error Tracking

Gust Shell

• Shell DAGs — YAML and shell command orchestration
• Task Options — Process control, environment, and output handling

Gust Web

• Installation
• MCP Server
• HTTP API

Gust Python

• Installation
• Writing Python DAGs
• Under the Hood

Repo

• Contributing

---

Benchmark

Gust is significantly more resource-efficient than Apache Airflow, requiring up to 4.4× less memory when idle and roughly half the peak RAM to handle identical parallel workloads, while maintaining a lower CPU footprint during orchestration.

See the gust-benchmark repo for the full methodology, results, and how to reproduce it.

---

Sponsors

Find the best offers and save money on car subscription service.

License

Gust is released under the MIT License.

---