Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/BabySid/aether/llms.txt

Use this file to discover all available pages before exploring further.

Aether is a Go framework for building workflow orchestration systems. It implements the Graph Workflow Protocol (aether/v1), a declarative protocol for expressing workflows as JSON documents with typed resources — Workflow, CronWorkflow, and WorkflowTemplate. Aether handles DAG scheduling, loop iteration, conditional branching, retry/timeout policies, cron scheduling, and suspend/resume patterns, while delegating all execution logic to pluggable backends you control.

Quickstart

Wire up the engine and run your first workflow in minutes

Architecture

Understand the hexagonal design and how all pieces fit together

Core Concepts

Learn the workflow model, templates, phases, and parameter binding

Extension Points

Implement custom executors, stores, and brokers for your infrastructure

​
What Aether provides

Aether is a scheduler and coordinator — it never executes task logic itself. All execution is delegated to pluggable executor.Plugin implementations dispatched through a broker.TaskBroker. This separation means your workers can run in-process, in separate goroutines, or on remote machines without changing the engine.

DAG Orchestration

Dependency-driven task scheduling with parallel execution and conditional branching

Loop Primitives

Static item lists, dynamic itemsFrom, and repeatCondition loops with concurrency control

Cron Scheduling

Periodic workflow execution with Allow, Forbid, and Replace concurrency policies

Retry & Timeout

Per-task retry policies with expression-based conditions and deadline enforcement

Suspend & Resume

First-class human-approval gates and external callback patterns

Lifecycle Hooks

Workflow and task-level event notifications for monitoring and automation

​
Get started

1

Install the module

Add Aether to your Go module. The core engine has zero external dependencies.
go get github.com/BabySid/aether@latest
2

Implement required interfaces

Provide a store.Store, broker.TaskBroker, executor.Plugin, and idgen.Generator. Start with in-memory implementations for development — see the Quickstart for working examples.
3

Create and start the engine

Wire everything together with functional options and call Start() to launch background services.
engine, err := aether.New(
    aether.WithStore(myStore),
    aether.WithExecutor(myExecutor),
    aether.WithTaskBroker(myBroker),
    aether.WithIDGenerator(myIDGen),
)
engine.Start(ctx)
4

Submit workflows

Define workflows as model.Workflow structs using the aether/v1 protocol and submit them for execution.
runID, err := engine.Submit(ctx, &model.Workflow{
    APIVersion: "aether/v1",
    Kind:       "Workflow",
    // ...
})

​
Protocol-first design

Aether defines a declarative protocol rather than an imperative framework. Workflows are expressed as JSON/struct documents, following the Kubernetes resource model. The engine is a runtime that interprets these documents — not a library you extend by subclassing. 
{
  "apiVersion": "aether/v1",
  "kind": "Workflow",
  "metadata": { "name": "my-pipeline" },
  "spec": {
    "entrypoint": "main",
    "templates": [
      {
        "dag": {
          "name": "main",
          "tasks": [
            { "name": "fetch", "template": "fetch-data" },
            { "name": "process", "template": "process-data", "dependencies": ["fetch"] }
          ]
        }
      }
    ]
  }
}
Aether’s core engine has zero external dependencies. All infrastructure concerns (state persistence, task dispatch, expression evaluation, secrets, etc.) are injected via interfaces — you choose the implementations.

Build docs developers (and LLMs) love

Get started for freeTalk to us